RTEMS 4.11
Annotated Report
Thu Dec 20 14:12:14 2012

0200b5f0 <IMFS_chown>:                                                
int IMFS_chown(                                                       
  const rtems_filesystem_location_info_t *loc,                        
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
 200b5f0:	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();                                                 
 200b5f4:	40 00 02 4a 	call  200bf1c <geteuid>                        
 200b5f8:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
 200b5fc:	c2 17 60 3c 	lduh  [ %i5 + 0x3c ], %g1                      
 200b600:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 200b604:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 200b608:	80 a2 00 01 	cmp  %o0, %g1                                  
 200b60c:	02 80 00 0a 	be  200b634 <IMFS_chown+0x44>                  
 200b610:	80 a2 20 00 	cmp  %o0, 0                                    
 200b614:	22 80 00 09 	be,a   200b638 <IMFS_chown+0x48>               <== NEVER TAKEN
 200b618:	f2 37 60 3c 	sth  %i1, [ %i5 + 0x3c ]                       <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EPERM );                    
 200b61c:	40 00 10 14 	call  200f66c <__errno>                        
 200b620:	b0 10 3f ff 	mov  -1, %i0                                   
 200b624:	82 10 20 01 	mov  1, %g1                                    
 200b628:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200b62c:	81 c7 e0 08 	ret                                            
 200b630:	81 e8 00 00 	restore                                        
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
 200b634:	f2 37 60 3c 	sth  %i1, [ %i5 + 0x3c ]                       
  jnode->st_gid = group;                                              
 200b638:	f4 37 60 3e 	sth  %i2, [ %i5 + 0x3e ]                       
                                                                      
  IMFS_update_ctime( jnode );                                         
 200b63c:	90 07 bf f8 	add  %fp, -8, %o0                              
 200b640:	7f ff e0 06 	call  2003658 <gettimeofday>                   
 200b644:	92 10 20 00 	clr  %o1                                       
 200b648:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200b64c:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
  return 0;                                                           
}                                                                     
 200b650:	81 c7 e0 08 	ret                                            
 200b654:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02005690 <IMFS_dump_directory>: */ static void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) {
 2005690:	9d e3 bf a0 	save  %sp, -96, %sp                            
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
 2005694:	35 00 80 87 	sethi  %hi(0x2021c00), %i2                     
 2005698:	39 00 80 8f 	sethi  %hi(0x2023c00), %i4                     
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
 200569c:	21 00 80 87 	sethi  %hi(0x2021c00), %l0                     
      return;                                                         
  }                                                                   
  puts("");                                                           
 20056a0:	23 00 80 87 	sethi  %hi(0x2021c00), %l1                     
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
 20056a4:	25 00 80 87 	sethi  %hi(0x2021c00), %l2                     
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 20056a8:	fa 06 20 50 	ld  [ %i0 + 0x50 ], %i5                        
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
 20056ac:	b4 16 a2 a0 	or  %i2, 0x2a0, %i2                            
 20056b0:	b8 17 23 d0 	or  %i4, 0x3d0, %i4                            
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
 20056b4:	a0 14 23 10 	or  %l0, 0x310, %l0                            
      return;                                                         
  }                                                                   
  puts("");                                                           
 20056b8:	a2 14 62 38 	or  %l1, 0x238, %l1                            
  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 );                    
 20056bc:	10 80 00 4d 	b  20057f0 <IMFS_dump_directory+0x160>         
 20056c0:	a4 14 a2 f8 	or  %l2, 0x2f8, %l2                            
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
 20056c4:	90 10 00 1a 	mov  %i2, %o0                                  
 20056c8:	40 00 38 f0 	call  2013a88 <fputs>                          
 20056cc:	b6 06 e0 01 	inc  %i3                                       
 20056d0:	10 80 00 03 	b  20056dc <IMFS_dump_directory+0x4c>          
 20056d4:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 20056d8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
        !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++ )                                      
 20056dc:	80 a6 c0 19 	cmp  %i3, %i1                                  
 20056e0:	04 bf ff f9 	ble  20056c4 <IMFS_dump_directory+0x34>        
 20056e4:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
  IMFS_jnode_t *the_jnode                                             
)                                                                     
{                                                                     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
 20056e8:	40 00 38 e8 	call  2013a88 <fputs>                          
 20056ec:	90 07 60 0c 	add  %i5, 0xc, %o0                             
  rtems_chain_extract_unprotected( &node->Node );                     
}                                                                     
                                                                      
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{                                                                     
  return node->control->imfs_type;                                    
 20056f0:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
 20056f4:	d4 00 40 00 	ld  [ %g1 ], %o2                               
  switch( IMFS_type( the_jnode ) ) {                                  
 20056f8:	80 a2 a0 06 	cmp  %o2, 6                                    
 20056fc:	38 80 00 2d 	bgu,a   20057b0 <IMFS_dump_directory+0x120>    <== NEVER TAKEN
 2005700:	c2 07 00 00 	ld  [ %i4 ], %g1                               <== NOT EXECUTED
 2005704:	95 2a a0 02 	sll  %o2, 2, %o2                               
 2005708:	03 00 80 15 	sethi  %hi(0x2005400), %g1                     
 200570c:	82 10 62 74 	or  %g1, 0x274, %g1	! 2005674 <bsp_interrupt_handler_default+0x18>
 2005710:	c2 00 40 0a 	ld  [ %g1 + %o2 ], %g1                         
 2005714:	81 c0 40 00 	jmp  %g1                                       
 2005718:	01 00 00 00 	nop                                            
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
 200571c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 2005720:	90 10 20 2f 	mov  0x2f, %o0                                 
 2005724:	40 00 38 a5 	call  20139b8 <fputc>                          
 2005728:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
 200572c:	30 80 00 26 	b,a   20057c4 <IMFS_dump_directory+0x134>      
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
 2005730:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 2005734:	13 00 80 87 	sethi  %hi(0x2021c00), %o1                     
 2005738:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
 200573c:	92 12 62 a8 	or  %o1, 0x2a8, %o1                            
 2005740:	10 80 00 08 	b  2005760 <IMFS_dump_directory+0xd0>          
 2005744:	d4 1f 60 50 	ldd  [ %i5 + 0x50 ], %o2                       
        the_jnode->info.device.major, the_jnode->info.device.minor ); 
      break;                                                          
                                                                      
    case IMFS_LINEAR_FILE:                                            
      fprintf(stdout, " (file %" PRId32 " %p)",                       
 2005748:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 200574c:	d4 07 60 54 	ld  [ %i5 + 0x54 ], %o2                        
 2005750:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
 2005754:	d6 07 60 58 	ld  [ %i5 + 0x58 ], %o3                        
 2005758:	13 00 80 87 	sethi  %hi(0x2021c00), %o1                     
 200575c:	92 12 62 c0 	or  %o1, 0x2c0, %o1	! 2021ec0 <Configuration_Initial_Extensions+0x16a0>
 2005760:	40 00 38 7a 	call  2013948 <fprintf>                        
 2005764:	01 00 00 00 	nop                                            
 2005768:	30 80 00 17 	b,a   20057c4 <IMFS_dump_directory+0x134>      
        the_jnode->info.file.indirect,                                
        the_jnode->info.file.doubly_indirect,                         
        the_jnode->info.file.triply_indirect                          
      );                                                              
#else                                                                 
      fprintf(stdout, " (file %" PRId32 ")",                          
 200576c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 2005770:	d4 07 60 54 	ld  [ %i5 + 0x54 ], %o2                        
 2005774:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
 2005778:	13 00 80 87 	sethi  %hi(0x2021c00), %o1                     
 200577c:	40 00 38 73 	call  2013948 <fprintf>                        
 2005780:	92 12 62 d0 	or  %o1, 0x2d0, %o1	! 2021ed0 <Configuration_Initial_Extensions+0x16b0>
 2005784:	30 80 00 10 	b,a   20057c4 <IMFS_dump_directory+0x134>      
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
 2005788:	11 00 80 87 	sethi  %hi(0x2021c00), %o0                     
 200578c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 2005790:	10 80 00 04 	b  20057a0 <IMFS_dump_directory+0x110>         
 2005794:	90 12 22 e0 	or  %o0, 0x2e0, %o0                            
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
 2005798:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 200579c:	90 10 00 12 	mov  %l2, %o0                                  
 20057a0:	40 00 38 ba 	call  2013a88 <fputs>                          
 20057a4:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
}                                                                     
                                                                      
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )      
{                                                                     
  return node->control->imfs_type == IMFS_DIRECTORY;                  
 20057a8:	10 80 00 0a 	b  20057d0 <IMFS_dump_directory+0x140>         
 20057ac:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
 20057b0:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 20057b4:	40 00 38 65 	call  2013948 <fprintf>                        <== NOT EXECUTED
 20057b8:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
 20057bc:	10 80 00 05 	b  20057d0 <IMFS_dump_directory+0x140>         <== NOT EXECUTED
 20057c0:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        <== NOT EXECUTED
      return;                                                         
  }                                                                   
  puts("");                                                           
 20057c4:	40 00 3f 98 	call  2015624 <puts>                           
 20057c8:	90 10 00 11 	mov  %l1, %o0                                  
 20057cc:	c2 07 60 4c 	ld  [ %i5 + 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 ) )                             
 20057d0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 20057d4:	80 a0 60 00 	cmp  %g1, 0                                    
 20057d8:	32 80 00 06 	bne,a   20057f0 <IMFS_dump_directory+0x160>    
 20057dc:	fa 07 40 00 	ld  [ %i5 ], %i5                               
      IMFS_dump_directory( the_jnode, level + 1 );                    
 20057e0:	90 10 00 1d 	mov  %i5, %o0                                  
 20057e4:	7f ff ff ab 	call  2005690 <IMFS_dump_directory>            
 20057e8:	92 06 60 01 	add  %i1, 1, %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 ) {                                 
 20057ec:	fa 07 40 00 	ld  [ %i5 ], %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 ));            
 20057f0:	82 06 20 54 	add  %i0, 0x54, %g1                            
  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 );                    
 20057f4:	80 a7 40 01 	cmp  %i5, %g1                                  
 20057f8:	12 bf ff b8 	bne  20056d8 <IMFS_dump_directory+0x48>        
 20057fc:	b6 10 20 00 	clr  %i3                                       
      fprintf(stdout, "...." );                                       
    IMFS_print_jnode( the_jnode );                                    
    if ( IMFS_is_directory( the_jnode ) )                             
      IMFS_dump_directory( the_jnode, level + 1 );                    
  }                                                                   
}                                                                     
 2005800:	81 c7 e0 08 	ret                                            
 2005804:	81 e8 00 00 	restore                                        
                                                                      

0200b794 <IMFS_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
 200b794:	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;                        
 200b798:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
  bool access_ok = rtems_filesystem_eval_path_check_access(           
 200b79c:	90 10 00 18 	mov  %i0, %o0                                  
 200b7a0:	d4 07 20 30 	ld  [ %i4 + 0x30 ], %o2                        
 200b7a4:	d6 17 20 3c 	lduh  [ %i4 + 0x3c ], %o3                      
 200b7a8:	d8 17 20 3e 	lduh  [ %i4 + 0x3e ], %o4                      
 200b7ac:	40 00 02 f3 	call  200c378 <rtems_filesystem_eval_path_check_access>
 200b7b0:	92 10 20 01 	mov  1, %o1                                    
    dir->st_mode,                                                     
    dir->st_uid,                                                      
    dir->st_gid                                                       
  );                                                                  
                                                                      
  if ( access_ok ) {                                                  
 200b7b4:	80 8a 20 ff 	btst  0xff, %o0                                
 200b7b8:	12 80 00 04 	bne  200b7c8 <IMFS_eval_token+0x34>            
 200b7bc:	80 a6 e0 01 	cmp  %i3, 1                                    
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 200b7c0:	81 c7 e0 08 	ret                                            
 200b7c4:	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] == '.';                           
 200b7c8:	12 80 00 06 	bne  200b7e0 <IMFS_eval_token+0x4c>            
 200b7cc:	82 10 20 00 	clr  %g1                                       
 200b7d0:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
 200b7d4:	82 18 60 2e 	xor  %g1, 0x2e, %g1                            
 200b7d8:	80 a0 00 01 	cmp  %g0, %g1                                  
 200b7dc:	82 60 3f ff 	subx  %g0, -1, %g1                             
  IMFS_jnode_t *dir,                                                  
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {   
 200b7e0:	80 a0 60 00 	cmp  %g1, 0                                    
 200b7e4:	12 80 00 2b 	bne  200b890 <IMFS_eval_token+0xfc>            
 200b7e8:	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] == '.';       
 200b7ec:	12 80 00 0b 	bne  200b818 <IMFS_eval_token+0x84>            
 200b7f0:	80 a0 60 00 	cmp  %g1, 0                                    
 200b7f4:	c4 4e 80 00 	ldsb  [ %i2 ], %g2                             
 200b7f8:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
 200b7fc:	12 80 00 07 	bne  200b818 <IMFS_eval_token+0x84>            
 200b800:	80 a0 60 00 	cmp  %g1, 0                                    
 200b804:	c2 4e a0 01 	ldsb  [ %i2 + 1 ], %g1                         
 200b808:	82 18 60 2e 	xor  %g1, 0x2e, %g1                            
 200b80c:	80 a0 00 01 	cmp  %g0, %g1                                  
 200b810:	82 60 3f ff 	subx  %g0, -1, %g1                             
    return dir;                                                       
  } else {                                                            
    if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {  
 200b814:	80 a0 60 00 	cmp  %g1, 0                                    
 200b818:	22 80 00 04 	be,a   200b828 <IMFS_eval_token+0x94>          
 200b81c:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
      return dir->Parent;                                             
 200b820:	10 80 00 17 	b  200b87c <IMFS_eval_token+0xe8>              
 200b824:	fa 07 20 08 	ld  [ %i4 + 8 ], %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 );           
 200b828:	10 80 00 10 	b  200b868 <IMFS_eval_token+0xd4>              
 200b82c:	b2 07 20 54 	add  %i4, 0x54, %i1                            
                                                                      
      while ( current != tail ) {                                     
        IMFS_jnode_t *entry = (IMFS_jnode_t *) current;               
        bool match = strncmp( entry->name, token, tokenlen ) == 0     
 200b830:	92 10 00 1a 	mov  %i2, %o1                                  
 200b834:	40 00 15 47 	call  2010d50 <strncmp>                        
 200b838:	94 10 00 1b 	mov  %i3, %o2                                  
          && entry->name [tokenlen] == '\0';                          
 200b83c:	80 a2 20 00 	cmp  %o0, 0                                    
 200b840:	12 80 00 06 	bne  200b858 <IMFS_eval_token+0xc4>            
 200b844:	82 10 20 00 	clr  %g1                                       
 200b848:	82 07 40 1b 	add  %i5, %i3, %g1                             
 200b84c:	c2 48 60 0c 	ldsb  [ %g1 + 0xc ], %g1                       
 200b850:	80 a0 00 01 	cmp  %g0, %g1                                  
 200b854:	82 60 3f ff 	subx  %g0, -1, %g1                             
                                                                      
        if ( match ) {                                                
 200b858:	80 a0 60 00 	cmp  %g1, 0                                    
 200b85c:	12 80 00 09 	bne  200b880 <IMFS_eval_token+0xec>            
 200b860:	80 a7 60 00 	cmp  %i5, 0                                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
 200b864:	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 ) {                                     
 200b868:	80 a7 40 19 	cmp  %i5, %i1                                  
 200b86c:	12 bf ff f1 	bne  200b830 <IMFS_eval_token+0x9c>            
 200b870:	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;           
 200b874:	81 c7 e0 08 	ret                                            
 200b878:	91 e8 20 02 	restore  %g0, 2, %o0                           
  );                                                                  
                                                                      
  if ( access_ok ) {                                                  
    IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
                                                                      
    if ( entry != NULL ) {                                            
 200b87c:	80 a7 60 00 	cmp  %i5, 0                                    
 200b880:	32 80 00 06 	bne,a   200b898 <IMFS_eval_token+0x104>        
 200b884:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
            rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );   
          }                                                           
        }                                                             
      }                                                               
    } else {                                                          
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
 200b888:	81 c7 e0 08 	ret                                            
 200b88c:	91 e8 20 02 	restore  %g0, 2, %o0                           
  IMFS_jnode_t *dir,                                                  
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {   
 200b890:	ba 10 00 1c 	mov  %i4, %i5                                  
                                                                      
  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 );    
 200b894:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
                                                                      
static inline int rtems_filesystem_eval_path_get_flags(               
  const rtems_filesystem_eval_path_context_t *ctx                     
)                                                                     
{                                                                     
  return ctx->flags;                                                  
 200b898:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
 200b89c:	80 a0 00 01 	cmp  %g0, %g1                                  
  rtems_chain_extract_unprotected( &node->Node );                     
}                                                                     
                                                                      
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{                                                                     
  return node->control->imfs_type;                                    
 200b8a0:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
 200b8a4:	84 60 3f ff 	subx  %g0, -1, %g2                             
 200b8a8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
 200b8ac:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
      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)) {
 200b8b0:	80 a0 60 02 	cmp  %g1, 2                                    
 200b8b4:	12 80 00 0a 	bne  200b8dc <IMFS_eval_token+0x148>           
 200b8b8:	88 10 00 02 	mov  %g2, %g4                                  
 200b8bc:	80 a0 a0 00 	cmp  %g2, 0                                    
 200b8c0:	22 80 00 2b 	be,a   200b96c <IMFS_eval_token+0x1d8>         
 200b8c4:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
 200b8c8:	80 88 e0 08 	btst  8, %g3                                   
 200b8cc:	22 80 00 29 	be,a   200b970 <IMFS_eval_token+0x1dc>         
 200b8d0:	c2 17 20 34 	lduh  [ %i4 + 0x34 ], %g1                      
        entry = entry->info.hard_link.link_node;                      
 200b8d4:	10 80 00 26 	b  200b96c <IMFS_eval_token+0x1d8>             
 200b8d8:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
      }                                                               
                                                                      
      if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) { 
 200b8dc:	80 a0 60 03 	cmp  %g1, 3                                    
 200b8e0:	12 80 00 10 	bne  200b920 <IMFS_eval_token+0x18c>           
 200b8e4:	80 a0 60 00 	cmp  %g1, 0                                    
 200b8e8:	80 a0 a0 00 	cmp  %g2, 0                                    
 200b8ec:	02 80 00 04 	be  200b8fc <IMFS_eval_token+0x168>            
 200b8f0:	80 88 e0 10 	btst  0x10, %g3                                
 200b8f4:	22 80 00 1f 	be,a   200b970 <IMFS_eval_token+0x1dc>         
 200b8f8:	c2 17 20 34 	lduh  [ %i4 + 0x34 ], %g1                      
        const char *target = entry->info.sym_link.name;               
 200b8fc:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
                                                                      
        rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
 200b900:	40 00 14 e2 	call  2010c88 <strlen>                         
 200b904:	90 10 00 1d 	mov  %i5, %o0                                  
 200b908:	92 10 00 1d 	mov  %i5, %o1                                  
 200b90c:	94 10 00 08 	mov  %o0, %o2                                  
 200b910:	7f ff e4 38 	call  20049f0 <rtems_filesystem_eval_path_recursive>
 200b914:	90 10 00 18 	mov  %i0, %o0                                  
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 200b918:	81 c7 e0 08 	ret                                            
 200b91c:	91 e8 20 01 	restore  %g0, 1, %o0                           
  IMFS_jnode_types_t type                                             
)                                                                     
{                                                                     
  rtems_filesystem_global_location_t **fs_root_ptr = NULL;            
                                                                      
  if ( type == IMFS_DIRECTORY ) {                                     
 200b920:	32 80 00 14 	bne,a   200b970 <IMFS_eval_token+0x1dc>        
 200b924:	c2 17 20 34 	lduh  [ %i4 + 0x34 ], %g1                      
    if ( node->info.directory.mt_fs != NULL ) {                       
 200b928:	d2 07 60 5c 	ld  [ %i5 + 0x5c ], %o1                        
 200b92c:	80 a2 60 00 	cmp  %o1, 0                                    
 200b930:	02 80 00 0f 	be  200b96c <IMFS_eval_token+0x1d8>            
 200b934:	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(        
 200b938:	d4 07 60 30 	ld  [ %i5 + 0x30 ], %o2                        
 200b93c:	d6 17 60 3c 	lduh  [ %i5 + 0x3c ], %o3                      
 200b940:	d8 17 60 3e 	lduh  [ %i5 + 0x3e ], %o4                      
{                                                                     
  rtems_filesystem_global_location_t **fs_root_ptr = NULL;            
                                                                      
  if ( type == IMFS_DIRECTORY ) {                                     
    if ( node->info.directory.mt_fs != NULL ) {                       
      fs_root_ptr = &node->info.directory.mt_fs->mt_fs_root;          
 200b944:	b8 02 60 24 	add  %o1, 0x24, %i4                            
                                                                      
          if ( !terminal ) {                                          
            status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;     
          }                                                           
        } else {                                                      
          access_ok = rtems_filesystem_eval_path_check_access(        
 200b948:	40 00 02 8c 	call  200c378 <rtems_filesystem_eval_path_check_access>
 200b94c:	92 10 20 01 	mov  1, %o1                                    
            RTEMS_FS_PERMS_EXEC,                                      
            entry->st_mode,                                           
            entry->st_uid,                                            
            entry->st_gid                                             
          );                                                          
          if ( access_ok ) {                                          
 200b950:	80 8a 20 ff 	btst  0xff, %o0                                
 200b954:	02 80 00 04 	be  200b964 <IMFS_eval_token+0x1d0>            <== NEVER TAKEN
 200b958:	90 10 00 18 	mov  %i0, %o0                                  
            rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );   
 200b95c:	7f ff e4 0c 	call  200498c <rtems_filesystem_eval_path_restart>
 200b960:	92 10 00 1c 	mov  %i4, %o1                                  
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 200b964:	81 c7 e0 08 	ret                                            
 200b968:	91 e8 20 01 	restore  %g0, 1, %o0                           
      } else {                                                        
        rtems_filesystem_global_location_t **fs_root_ptr =            
          IMFS_is_mount_point( entry, type );                         
                                                                      
        if ( fs_root_ptr == NULL ) {                                  
          --dir->reference_count;                                     
 200b96c:	c2 17 20 34 	lduh  [ %i4 + 0x34 ], %g1                      
 200b970:	82 00 7f ff 	add  %g1, -1, %g1                              
 200b974:	c2 37 20 34 	sth  %g1, [ %i4 + 0x34 ]                       
          ++entry->reference_count;                                   
 200b978:	c2 17 60 34 	lduh  [ %i5 + 0x34 ], %g1                      
 200b97c:	82 00 60 01 	inc  %g1                                       
 200b980:	c2 37 60 34 	sth  %g1, [ %i5 + 0x34 ]                       
                                                                      
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;                            
 200b984:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
          currentloc->node_access = entry;                            
 200b988:	fa 26 20 20 	st  %i5, [ %i0 + 0x20 ]                        
 200b98c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 200b990:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 200b994:	b0 09 20 ff 	and  %g4, 0xff, %i0                            
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
 200b998:	81 c7 e0 08 	ret                                            
 200b99c:	81 e8 00 00 	restore                                        
                                                                      

0200b9b8 <IMFS_fchmod>: int IMFS_fchmod( const rtems_filesystem_location_info_t *loc, mode_t mode ) {
 200b9b8:	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();                                                 
 200b9bc:	40 00 01 58 	call  200bf1c <geteuid>                        
 200b9c0:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
 200b9c4:	c2 17 60 3c 	lduh  [ %i5 + 0x3c ], %g1                      
 200b9c8:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 200b9cc:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 200b9d0:	80 a2 00 01 	cmp  %o0, %g1                                  
 200b9d4:	02 80 00 0a 	be  200b9fc <IMFS_fchmod+0x44>                 
 200b9d8:	80 a2 20 00 	cmp  %o0, 0                                    
 200b9dc:	22 80 00 09 	be,a   200ba00 <IMFS_fchmod+0x48>              <== NEVER TAKEN
 200b9e0:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
    rtems_set_errno_and_return_minus_one( EPERM );                    
 200b9e4:	40 00 0f 22 	call  200f66c <__errno>                        
 200b9e8:	b0 10 3f ff 	mov  -1, %i0                                   
 200b9ec:	82 10 20 01 	mov  1, %g1                                    
 200b9f0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200b9f4:	81 c7 e0 08 	ret                                            
 200b9f8:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   * 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);
 200b9fc:	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 );                                         
 200ba00:	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);
 200ba04:	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 );                                         
 200ba08:	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);
 200ba0c:	b2 0e 6f ff 	and  %i1, 0xfff, %i1                           
 200ba10:	b2 16 40 01 	or  %i1, %g1, %i1                              
                                                                      
  IMFS_update_ctime( jnode );                                         
 200ba14:	7f ff df 11 	call  2003658 <gettimeofday>                   
 200ba18:	f2 27 60 30 	st  %i1, [ %i5 + 0x30 ]                        
 200ba1c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200ba20:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
  return 0;                                                           
}                                                                     
 200ba24:	81 c7 e0 08 	ret                                            
 200ba28:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02003890 <IMFS_fifo_write>: static ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
 2003890:	9d e3 bf 98 	save  %sp, -104, %sp                           
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
 2003894:	fa 06 20 1c 	ld  [ %i0 + 0x1c ], %i5                        
                                                                      
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
 2003898:	96 10 00 18 	mov  %i0, %o3                                  
 200389c:	d0 07 60 50 	ld  [ %i5 + 0x50 ], %o0                        
 20038a0:	92 10 00 19 	mov  %i1, %o1                                  
 20038a4:	40 00 2a 97 	call  200e300 <pipe_write>                     
 20038a8:	94 10 00 1a 	mov  %i2, %o2                                  
  if (err > 0) {                                                      
 20038ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20038b0:	04 80 00 09 	ble  20038d4 <IMFS_fifo_write+0x44>            
 20038b4:	90 07 bf f8 	add  %fp, -8, %o0                              
    IMFS_mtime_ctime_update(jnode);                                   
 20038b8:	40 00 04 0e 	call  20048f0 <gettimeofday>                   
 20038bc:	92 10 20 00 	clr  %o1                                       
 20038c0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 20038c4:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
 20038c8:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
 20038cc:	81 c7 e0 08 	ret                                            
 20038d0:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
 20038d4:	80 a6 20 00 	cmp  %i0, 0                                    
 20038d8:	02 80 00 06 	be  20038f0 <IMFS_fifo_write+0x60>             <== NEVER TAKEN
 20038dc:	01 00 00 00 	nop                                            
 20038e0:	40 00 37 66 	call  2011678 <__errno>                        
 20038e4:	b0 20 00 18 	neg  %i0                                       
 20038e8:	f0 22 00 00 	st  %i0, [ %o0 ]                               
 20038ec:	b0 10 3f ff 	mov  -1, %i0                                   
}                                                                     
 20038f0:	81 c7 e0 08 	ret                                            
 20038f4:	81 e8 00 00 	restore                                        
                                                                      

0200ba2c <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 ) {
 200ba2c:	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;                         
 200ba30:	f6 06 20 24 	ld  [ %i0 + 0x24 ], %i3                        
 200ba34:	b8 07 bf e8 	add  %fp, -24, %i4                             
 200ba38:	92 10 00 1b 	mov  %i3, %o1                                  
 200ba3c:	90 10 00 1c 	mov  %i4, %o0                                  
 200ba40:	40 00 11 5c 	call  200ffb0 <memcpy>                         
 200ba44:	94 10 20 18 	mov  0x18, %o2                                 
   jnode = (IMFS_jnode_t *)loc.node_access;                           
 200ba48:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5                         
                                                                      
   /*                                                                 
    *  Set this to null to indicate that it is being unmounted.       
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
 200ba4c:	c0 26 e0 08 	clr  [ %i3 + 8 ]                               
 200ba50:	b6 10 00 1c 	mov  %i4, %i3                                  
 200ba54:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
 200ba58:	f8 07 60 08 	ld  [ %i5 + 8 ], %i4                           
 200ba5c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
     loc.node_access = (void *)jnode;                                 
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
 200ba60:	c2 00 40 00 	ld  [ %g1 ], %g1                               
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
     loc.node_access = (void *)jnode;                                 
 200ba64:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
 200ba68:	80 a0 60 00 	cmp  %g1, 0                                    
 200ba6c:	12 80 00 07 	bne  200ba88 <IMFS_fsunmount+0x5c>             
 200ba70:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
 200ba74:	c4 07 60 50 	ld  [ %i5 + 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 );                            
 200ba78:	82 07 60 54 	add  %i5, 0x54, %g1                            
 200ba7c:	80 a0 80 01 	cmp  %g2, %g1                                  
 200ba80:	32 80 00 10 	bne,a   200bac0 <IMFS_fsunmount+0x94>          
 200ba84:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
        result = IMFS_rmnod( NULL, &loc );                            
 200ba88:	90 10 20 00 	clr  %o0                                       
 200ba8c:	7f ff dd 7d 	call  2003080 <IMFS_rmnod>                     
 200ba90:	92 10 00 1b 	mov  %i3, %o1                                  
        if ( result != 0 )                                            
 200ba94:	80 a2 20 00 	cmp  %o0, 0                                    
 200ba98:	02 80 00 04 	be  200baa8 <IMFS_fsunmount+0x7c>              <== ALWAYS TAKEN
 200ba9c:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
	  rtems_fatal_error_occurred( 0xdeadbeef );                          
 200baa0:	7f ff f0 e6 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 200baa4:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
        IMFS_node_destroy( jnode );                                   
 200baa8:	7f ff dc a4 	call  2002d38 <IMFS_node_destroy>              
 200baac:	90 10 00 1d 	mov  %i5, %o0                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
 200bab0:	80 a7 20 00 	cmp  %i4, 0                                    
 200bab4:	02 80 00 0e 	be  200baec <IMFS_fsunmount+0xc0>              
 200bab8:	ba 10 00 1c 	mov  %i4, %i5                                  
  return node->control->imfs_type;                                    
}                                                                     
                                                                      
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )      
{                                                                     
  return node->control->imfs_type == IMFS_DIRECTORY;                  
 200babc:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
       if ( IMFS_is_directory( jnode ) ) {                            
 200bac0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 200bac4:	80 a0 60 00 	cmp  %g1, 0                                    
 200bac8:	32 bf ff e4 	bne,a   200ba58 <IMFS_fsunmount+0x2c>          <== NEVER TAKEN
 200bacc:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 200bad0:	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 );                            
 200bad4:	84 07 60 54 	add  %i5, 0x54, %g2                            
         if ( jnode_has_children( jnode ) )                           
 200bad8:	80 a0 40 02 	cmp  %g1, %g2                                  
 200badc:	02 bf ff de 	be  200ba54 <IMFS_fsunmount+0x28>              
 200bae0:	80 a0 60 00 	cmp  %g1, 0                                    
           jnode = jnode_get_first_child( jnode );                    
       }                                                              
     }                                                                
   } while (jnode != NULL);                                           
 200bae4:	12 bf ff dc 	bne  200ba54 <IMFS_fsunmount+0x28>             <== ALWAYS TAKEN
 200bae8:	ba 10 00 01 	mov  %g1, %i5                                  
 200baec:	81 c7 e0 08 	ret                                            
 200baf0:	81 e8 00 00 	restore                                        
                                                                      

02002c2c <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] ) {
 2002c2c:	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 ) );          
 2002c30:	90 10 20 01 	mov  1, %o0                                    
 2002c34:	40 00 01 ac 	call  20032e4 <calloc>                         
 2002c38:	92 10 20 24 	mov  0x24, %o1                                 
                                                                      
  if ( fs_info != NULL ) {                                            
 2002c3c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2002c40:	02 80 00 24 	be  2002cd0 <IMFS_initialize_support+0xa4>     
 2002c44:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    IMFS_jnode_t *root_node;                                          
                                                                      
    fs_info->instance = imfs_instance++;                              
 2002c48:	c4 00 61 bc 	ld  [ %g1 + 0x1bc ], %g2	! 201d1bc <imfs_instance.6626>
    memcpy(                                                           
 2002c4c:	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++;                              
 2002c50:	c4 27 40 00 	st  %g2, [ %i5 ]                               
 2002c54:	84 00 a0 01 	inc  %g2                                       
    memcpy(                                                           
 2002c58:	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++;                              
 2002c5c:	c4 20 61 bc 	st  %g2, [ %g1 + 0x1bc ]                       
    memcpy(                                                           
 2002c60:	40 00 34 d4 	call  200ffb0 <memcpy>                         
 2002c64:	90 07 60 08 	add  %i5, 8, %o0                               
      fs_info->node_controls,                                         
      node_controls,                                                  
      sizeof( fs_info->node_controls )                                
    );                                                                
                                                                      
    root_node = IMFS_allocate_node(                                   
 2002c68:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
 2002c6c:	90 10 00 1d 	mov  %i5, %o0                                  
 2002c70:	15 00 80 6b 	sethi  %hi(0x201ac00), %o2                     
 2002c74:	96 10 20 00 	clr  %o3                                       
 2002c78:	94 12 a1 28 	or  %o2, 0x128, %o2                            
 2002c7c:	19 00 00 10 	sethi  %hi(0x4000), %o4                        
 2002c80:	9a 10 20 00 	clr  %o5                                       
 2002c84:	40 00 22 75 	call  200b658 <IMFS_allocate_node>             
 2002c88:	98 13 21 ed 	or  %o4, 0x1ed, %o4                            
      "",                                                             
      0,                                                              
      (S_IFDIR | 0755),                                               
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
 2002c8c:	80 a2 20 00 	cmp  %o0, 0                                    
 2002c90:	02 80 00 10 	be  2002cd0 <IMFS_initialize_support+0xa4>     <== NEVER TAKEN
 2002c94:	03 00 80 6d 	sethi  %hi(0x201b400), %g1                     
                                                                      
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;                            
 2002c98:	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;
 2002c9c:	82 10 62 14 	or  %g1, 0x214, %g1                            
 2002ca0:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
 2002ca4:	c2 26 20 2c 	st  %g1, [ %i0 + 0x2c ]                        
      mt_entry->mt_fs_root->location.node_access = root_node;         
 2002ca8:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
      0,                                                              
      (S_IFDIR | 0755),                                               
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
      mt_entry->fs_info = fs_info;                                    
 2002cac:	fa 26 20 08 	st  %i5, [ %i0 + 8 ]                           
      mt_entry->ops = op_table;                                       
 2002cb0:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
 2002cb4:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
      mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
      mt_entry->mt_fs_root->location.node_access = root_node;         
 2002cb8:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
    errno = ENOMEM;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    IMFS_determine_bytes_per_block(                                   
 2002cbc:	86 10 20 06 	mov  6, %g3                                    
 2002cc0:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
  int bit_mask;                                                       
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
 2002cc4:	84 10 20 10 	mov  0x10, %g2                                 
    errno = ENOMEM;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    IMFS_determine_bytes_per_block(                                   
 2002cc8:	10 80 00 08 	b  2002ce8 <IMFS_initialize_support+0xbc>      
 2002ccc:	c2 00 61 f0 	ld  [ %g1 + 0x1f0 ], %g1                       
    } else {                                                          
      errno = ENOMEM;                                                 
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOMEM;                                                   
 2002cd0:	40 00 32 67 	call  200f66c <__errno>                        
 2002cd4:	b0 10 3f ff 	mov  -1, %i0                                   
 2002cd8:	82 10 20 0c 	mov  0xc, %g1                                  
 2002cdc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2002ce0:	81 c7 e0 08 	ret                                            
 2002ce4:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   * 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) {                      
 2002ce8:	80 a0 80 01 	cmp  %g2, %g1                                  
 2002cec:	22 80 00 09 	be,a   2002d10 <IMFS_initialize_support+0xe4>  
 2002cf0:	05 00 80 74 	sethi  %hi(0x201d000), %g2                     
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
 2002cf4:	34 80 00 06 	bg,a   2002d0c <IMFS_initialize_support+0xe0>  
 2002cf8:	82 10 20 80 	mov  0x80, %g1                                 
  int bit_mask;                                                       
                                                                      
  /*                                                                  
   * check, whether requested bytes per block is valid                
   */                                                                 
  for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
 2002cfc:	86 80 ff ff 	addcc  %g3, -1, %g3                            
 2002d00:	12 bf ff fa 	bne  2002ce8 <IMFS_initialize_support+0xbc>    <== ALWAYS TAKEN
 2002d04:	85 28 a0 01 	sll  %g2, 1, %g2                               
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
			   ? requested_bytes_per_block                                     
			   : default_bytes_per_block);                                     
 2002d08:	82 10 20 80 	mov  0x80, %g1                                 <== NOT EXECUTED
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
 2002d0c:	05 00 80 74 	sethi  %hi(0x201d000), %g2                     
 2002d10:	c2 20 a1 b8 	st  %g1, [ %g2 + 0x1b8 ]	! 201d1b8 <imfs_memfile_bytes_per_block>
 2002d14:	b0 10 20 00 	clr  %i0                                       
      IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK                            
    );                                                                
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2002d18:	81 c7 e0 08 	ret                                            
 2002d1c:	81 e8 00 00 	restore                                        
                                                                      

02004874 <IMFS_make_generic_node>: const char *path, mode_t mode, const IMFS_node_control *node_control, void *context ) {
 2004874:	9d e3 bf 48 	save  %sp, -184, %sp                           
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
 2004878:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200487c:	c2 00 60 a4 	ld  [ %g1 + 0xa4 ], %g1	! 20214a4 <rtems_current_user_env>
                                                                      
  switch (mode & S_IFMT) {                                            
 2004880:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
  void *context                                                       
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
 2004884:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 2004888:	b2 2e 40 01 	andn  %i1, %g1, %i1                            
                                                                      
  switch (mode & S_IFMT) {                                            
 200488c:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 2004890:	82 0e 40 01 	and  %i1, %g1, %g1                             
 2004894:	80 a0 40 02 	cmp  %g1, %g2                                  
 2004898:	22 80 00 3a 	be,a   2004980 <IMFS_make_generic_node+0x10c>  
 200489c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 20048a0:	38 80 00 04 	bgu,a   20048b0 <IMFS_make_generic_node+0x3c>  <== ALWAYS TAKEN
 20048a4:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
 20048a8:	10 80 00 05 	b  20048bc <IMFS_make_generic_node+0x48>       <== NOT EXECUTED
 20048ac:	05 00 00 04 	sethi  %hi(0x1000), %g2                        <== NOT EXECUTED
 20048b0:	80 a0 40 02 	cmp  %g1, %g2                                  
 20048b4:	02 80 00 32 	be  200497c <IMFS_make_generic_node+0x108>     
 20048b8:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
 20048bc:	80 a0 40 02 	cmp  %g1, %g2                                  
 20048c0:	22 80 00 30 	be,a   2004980 <IMFS_make_generic_node+0x10c>  <== NEVER TAKEN
 20048c4:	c2 06 80 00 	ld  [ %i2 ], %g1                               <== NOT EXECUTED
 20048c8:	30 80 00 27 	b,a   2004964 <IMFS_make_generic_node+0xf0>    
    if ( node_control->imfs_type == IMFS_GENERIC ) {                  
      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 =            
 20048cc:	94 10 20 78 	mov  0x78, %o2                                 
 20048d0:	40 00 07 fa 	call  20068b8 <rtems_filesystem_eval_path_start>
 20048d4:	90 07 bf c8 	add  %fp, -56, %o0                             
        rtems_filesystem_eval_path_start( &ctx, path, eval_flags );   
                                                                      
      if ( IMFS_is_imfs_instance( currentloc ) ) {                    
 20048d8:	7f ff ff d5 	call  200482c <IMFS_is_imfs_instance>          
 20048dc:	ba 10 00 08 	mov  %o0, %i5                                  
 20048e0:	80 8a 20 ff 	btst  0xff, %o0                                
 20048e4:	02 80 00 19 	be  2004948 <IMFS_make_generic_node+0xd4>      
 20048e8:	90 07 bf c8 	add  %fp, -56, %o0                             
        IMFS_types_union info;                                        
        IMFS_jnode_t *new_node;                                       
                                                                      
        info.generic.context = context;                               
        new_node = IMFS_create_node_with_control(                     
 20048ec:	d4 1f bf d0 	ldd  [ %fp + -48 ], %o2                        
                                                                      
      if ( IMFS_is_imfs_instance( currentloc ) ) {                    
        IMFS_types_union info;                                        
        IMFS_jnode_t *new_node;                                       
                                                                      
        info.generic.context = context;                               
 20048f0:	f6 27 bf b0 	st  %i3, [ %fp + -80 ]                         
        new_node = IMFS_create_node_with_control(                     
 20048f4:	90 10 00 1d 	mov  %i5, %o0                                  
 20048f8:	92 10 00 1a 	mov  %i2, %o1                                  
 20048fc:	98 10 00 19 	mov  %i1, %o4                                  
 2004900:	9a 07 bf b0 	add  %fp, -80, %o5                             
 2004904:	40 00 2d 7a 	call  200feec <IMFS_create_node_with_control>  
 2004908:	b0 10 3f ff 	mov  -1, %i0                                   
          rtems_filesystem_eval_path_get_tokenlen( &ctx ),            
          mode,                                                       
          &info                                                       
        );                                                            
                                                                      
        if ( new_node != NULL ) {                                     
 200490c:	80 a2 20 00 	cmp  %o0, 0                                    
 2004910:	02 80 00 11 	be  2004954 <IMFS_make_generic_node+0xe0>      
 2004914:	92 10 20 00 	clr  %o1                                       
          IMFS_jnode_t *parent = currentloc->node_access;             
 2004918:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
          IMFS_update_ctime( parent );                                
 200491c:	40 00 02 90 	call  200535c <gettimeofday>                   
 2004920:	90 07 bf a8 	add  %fp, -88, %o0                             
 2004924:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
          IMFS_update_mtime( parent );                                
 2004928:	90 07 bf a8 	add  %fp, -88, %o0                             
        );                                                            
                                                                      
        if ( new_node != NULL ) {                                     
          IMFS_jnode_t *parent = currentloc->node_access;             
                                                                      
          IMFS_update_ctime( parent );                                
 200492c:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
          IMFS_update_mtime( parent );                                
 2004930:	40 00 02 8b 	call  200535c <gettimeofday>                   
 2004934:	92 10 20 00 	clr  %o1                                       
 2004938:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
 200493c:	b0 10 20 00 	clr  %i0                                       
 2004940:	10 80 00 05 	b  2004954 <IMFS_make_generic_node+0xe0>       
 2004944:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
        } else {                                                      
          rv = -1;                                                    
        }                                                             
      } else {                                                        
        rtems_filesystem_eval_path_error( &ctx, ENOTSUP );            
 2004948:	92 10 20 86 	mov  0x86, %o1                                 
 200494c:	40 00 07 45 	call  2006660 <rtems_filesystem_eval_path_error>
 2004950:	b0 10 3f ff 	mov  -1, %i0                                   
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
 2004954:	40 00 08 15 	call  20069a8 <rtems_filesystem_eval_path_cleanup>
 2004958:	90 07 bf c8 	add  %fp, -56, %o0                             
 200495c:	81 c7 e0 08 	ret                                            
 2004960:	81 e8 00 00 	restore                                        
    } else {                                                          
      errno = EINVAL;                                                 
 2004964:	40 00 3d a3 	call  2013ff0 <__errno>                        
 2004968:	b0 10 3f ff 	mov  -1, %i0                                   
 200496c:	82 10 20 16 	mov  0x16, %g1                                 
 2004970:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2004974:	81 c7 e0 08 	ret                                            
 2004978:	81 e8 00 00 	restore                                        
      rv = -1;                                                        
      break;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    if ( node_control->imfs_type == IMFS_GENERIC ) {                  
 200497c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 2004980:	80 a0 60 07 	cmp  %g1, 7                                    
 2004984:	02 bf ff d2 	be  20048cc <IMFS_make_generic_node+0x58>      
 2004988:	92 10 00 18 	mov  %i0, %o1                                  
 200498c:	30 bf ff f6 	b,a   2004964 <IMFS_make_generic_node+0xf0>    
                                                                      

0200e194 <IMFS_memfile_addblock>: */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) {
 200e194:	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 );
 200e198:	94 10 20 01 	mov  1, %o2                                    
 200e19c:	90 10 00 18 	mov  %i0, %o0                                  
 200e1a0:	7f ff fe d7 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e1a4:	92 10 00 19 	mov  %i1, %o1                                  
  if ( *block_entry_ptr )                                             
 200e1a8:	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 );
 200e1ac:	ba 10 00 08 	mov  %o0, %i5                                  
  if ( *block_entry_ptr )                                             
 200e1b0:	80 a0 60 00 	cmp  %g1, 0                                    
 200e1b4:	12 80 00 08 	bne  200e1d4 <IMFS_memfile_addblock+0x40>      
 200e1b8:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
                                                                      
  /*                                                                  
   *  There is no memory for this block number so allocate it.        
   */                                                                 
  memory = memfile_alloc_block();                                     
 200e1bc:	7f ff fe c3 	call  200dcc8 <memfile_alloc_block>            
 200e1c0:	01 00 00 00 	nop                                            
  if ( !memory )                                                      
 200e1c4:	80 a2 20 00 	cmp  %o0, 0                                    
 200e1c8:	22 80 00 03 	be,a   200e1d4 <IMFS_memfile_addblock+0x40>    <== NEVER TAKEN
 200e1cc:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
    return 1;                                                         
                                                                      
  *block_entry_ptr = memory;                                          
 200e1d0:	d0 27 40 00 	st  %o0, [ %i5 ]                               
  return 0;                                                           
 200e1d4:	81 c7 e0 08 	ret                                            
 200e1d8:	81 e8 00 00 	restore                                        
                                                                      

0200e3a8 <IMFS_memfile_extend>: MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, bool zero_fill, off_t new_length ) {
 200e3a8:	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 )                      
 200e3ac:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200e3b0:	fa 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i5	! 201d1b8 <imfs_memfile_bytes_per_block>
 200e3b4:	b9 37 60 02 	srl  %i5, 2, %i4                               
 200e3b8:	92 10 00 1c 	mov  %i4, %o1                                  
 200e3bc:	40 00 28 11 	call  2018400 <.umul>                          
 200e3c0:	90 07 20 01 	add  %i4, 1, %o0                               
 200e3c4:	92 10 00 1c 	mov  %i4, %o1                                  
 200e3c8:	40 00 28 0e 	call  2018400 <.umul>                          
 200e3cc:	90 02 20 01 	inc  %o0                                       
 200e3d0:	92 10 00 1d 	mov  %i5, %o1                                  
 200e3d4:	40 00 28 0b 	call  2018400 <.umul>                          
 200e3d8:	90 02 3f ff 	add  %o0, -1, %o0                              
 200e3dc:	82 10 20 00 	clr  %g1                                       
 200e3e0:	80 a0 40 1a 	cmp  %g1, %i2                                  
 200e3e4:	34 80 00 0b 	bg,a   200e410 <IMFS_memfile_extend+0x68>      <== NEVER TAKEN
 200e3e8:	f8 06 20 50 	ld  [ %i0 + 0x50 ], %i4                        <== NOT EXECUTED
 200e3ec:	80 a0 40 1a 	cmp  %g1, %i2                                  
 200e3f0:	12 80 00 04 	bne  200e400 <IMFS_memfile_extend+0x58>        <== NEVER TAKEN
 200e3f4:	80 a2 00 1b 	cmp  %o0, %i3                                  
 200e3f8:	38 80 00 06 	bgu,a   200e410 <IMFS_memfile_extend+0x68>     
 200e3fc:	f8 06 20 50 	ld  [ %i0 + 0x50 ], %i4                        
    rtems_set_errno_and_return_minus_one( EFBIG );                    
 200e400:	40 00 04 9b 	call  200f66c <__errno>                        
 200e404:	01 00 00 00 	nop                                            
 200e408:	10 80 00 3c 	b  200e4f8 <IMFS_memfile_extend+0x150>         
 200e40c:	82 10 20 1b 	mov  0x1b, %g1	! 1b <PROM_START+0x1b>          
                                                                      
  /*                                                                  
   *  Verify new file size is actually larger than current size       
   */                                                                 
  if ( new_length <= the_jnode->info.file.size )                      
 200e410:	80 a6 80 1c 	cmp  %i2, %i4                                  
 200e414:	14 80 00 07 	bg  200e430 <IMFS_memfile_extend+0x88>         <== NEVER TAKEN
 200e418:	e0 06 20 54 	ld  [ %i0 + 0x54 ], %l0                        
 200e41c:	80 a6 80 1c 	cmp  %i2, %i4                                  
 200e420:	12 80 00 48 	bne  200e540 <IMFS_memfile_extend+0x198>       <== NEVER TAKEN
 200e424:	80 a6 c0 10 	cmp  %i3, %l0                                  
 200e428:	08 80 00 46 	bleu  200e540 <IMFS_memfile_extend+0x198>      <== NEVER TAKEN
 200e42c:	01 00 00 00 	nop                                            
    return 0;                                                         
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
 200e430:	a3 3f 60 1f 	sra  %i5, 0x1f, %l1                            
 200e434:	96 10 00 1d 	mov  %i5, %o3                                  
 200e438:	94 10 00 11 	mov  %l1, %o2                                  
 200e43c:	90 10 00 1a 	mov  %i2, %o0                                  
 200e440:	40 00 29 82 	call  2018a48 <__divdi3>                       
 200e444:	92 10 00 1b 	mov  %i3, %o1                                  
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
 200e448:	94 10 00 11 	mov  %l1, %o2                                  
 200e44c:	90 10 00 1c 	mov  %i4, %o0                                  
 200e450:	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;             
 200e454:	a4 10 00 09 	mov  %o1, %l2                                  
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
 200e458:	40 00 29 7c 	call  2018a48 <__divdi3>                       
 200e45c:	92 10 00 10 	mov  %l0, %o1                                  
  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++ ) {            
 200e460:	a2 10 20 00 	clr  %l1                                       
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
  offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
 200e464:	90 10 00 09 	mov  %o1, %o0                                  
                                                                      
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
 200e468:	b8 10 00 09 	mov  %o1, %i4                                  
   *  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;       
 200e46c:	27 00 80 74 	sethi  %hi(0x201d000), %l3                     
  /*                                                                  
   *  Calculate the number of range of blocks to allocate             
   */                                                                 
  new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;             
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
  offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
 200e470:	40 00 27 e4 	call  2018400 <.umul>                          
 200e474:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
 200e478:	10 80 00 23 	b  200e504 <IMFS_memfile_extend+0x15c>         
 200e47c:	a0 24 00 08 	sub  %l0, %o0, %l0                             
    if ( !IMFS_memfile_addblock( the_jnode, block ) ) {               
 200e480:	7f ff ff 45 	call  200e194 <IMFS_memfile_addblock>          
 200e484:	92 10 00 1d 	mov  %i5, %o1                                  
 200e488:	80 a2 20 00 	cmp  %o0, 0                                    
 200e48c:	12 80 00 15 	bne  200e4e0 <IMFS_memfile_extend+0x138>       <== NEVER TAKEN
 200e490:	80 a6 60 00 	cmp  %i1, 0                                    
       if ( zero_fill ) {                                             
 200e494:	22 80 00 1c 	be,a   200e504 <IMFS_memfile_extend+0x15c>     
 200e498:	a2 04 60 01 	inc  %l1                                       
          size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;       
 200e49c:	e8 04 e1 b8 	ld  [ %l3 + 0x1b8 ], %l4                       
          block_p *block_ptr =                                        
 200e4a0:	92 10 00 1d 	mov  %i5, %o1                                  
 200e4a4:	94 10 20 00 	clr  %o2                                       
 200e4a8:	7f ff fe 15 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e4ac:	90 10 00 18 	mov  %i0, %o0                                  
            IMFS_memfile_get_block_pointer( the_jnode, block, 0 );    
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
 200e4b0:	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;       
 200e4b4:	a8 25 00 10 	sub  %l4, %l0, %l4                             
          block_p *block_ptr =                                        
            IMFS_memfile_get_block_pointer( the_jnode, block, 0 );    
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
 200e4b8:	90 02 00 10 	add  %o0, %l0, %o0                             
 200e4bc:	92 10 20 00 	clr  %o1                                       
 200e4c0:	94 10 00 14 	mov  %l4, %o2                                  
 200e4c4:	40 00 06 f8 	call  20100a4 <memset>                         
 200e4c8:	a0 10 20 00 	clr  %l0                                       
 200e4cc:	10 80 00 0e 	b  200e504 <IMFS_memfile_extend+0x15c>         
 200e4d0:	a2 04 60 01 	inc  %l1                                       
          offset = 0;                                                 
       }                                                              
    } else {                                                          
       for ( ; block>=old_blocks ; block-- ) {                        
         IMFS_memfile_remove_block( the_jnode, block );               
 200e4d4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200e4d8:	7f ff ff a8 	call  200e378 <IMFS_memfile_remove_block>      <== NOT EXECUTED
 200e4dc:	ba 07 7f ff 	add  %i5, -1, %i5                              <== NOT EXECUTED
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
          offset = 0;                                                 
       }                                                              
    } else {                                                          
       for ( ; block>=old_blocks ; block-- ) {                        
 200e4e0:	80 a7 40 1c 	cmp  %i5, %i4                                  <== NOT EXECUTED
 200e4e4:	1a bf ff fc 	bcc  200e4d4 <IMFS_memfile_extend+0x12c>       <== NOT EXECUTED
 200e4e8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
       }                                                              
       rtems_set_errno_and_return_minus_one( ENOSPC );                
 200e4ec:	40 00 04 60 	call  200f66c <__errno>                        <== NOT EXECUTED
 200e4f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200e4f4:	82 10 20 1c 	mov  0x1c, %g1	! 1c <PROM_START+0x1c>          <== NOT EXECUTED
 200e4f8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200e4fc:	81 c7 e0 08 	ret                                            
 200e500:	91 e8 3f ff 	restore  %g0, -1, %o0                          
 *                                                                    
 *  This routine insures that the in-memory file is of the length     
 *  specified.  If necessary, it will allocate memory blocks to       
 *  extend the file.                                                  
 */                                                                   
MEMFILE_STATIC int IMFS_memfile_extend(                               
 200e504:	ba 04 40 1c 	add  %l1, %i4, %i5                             
  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++ ) {            
 200e508:	80 a7 40 12 	cmp  %i5, %l2                                  
 200e50c:	08 bf ff dd 	bleu  200e480 <IMFS_memfile_extend+0xd8>       
 200e510:	90 10 00 18 	mov  %i0, %o0                                  
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
                                                                      
  IMFS_update_ctime(the_jnode);                                       
 200e514:	92 10 20 00 	clr  %o1                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
 200e518:	f4 3e 20 50 	std  %i2, [ %i0 + 0x50 ]                       
                                                                      
  IMFS_update_ctime(the_jnode);                                       
 200e51c:	7f ff d4 4f 	call  2003658 <gettimeofday>                   
 200e520:	90 07 bf f8 	add  %fp, -8, %o0                              
 200e524:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  IMFS_update_mtime(the_jnode);                                       
 200e528:	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);                                       
 200e52c:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
  IMFS_update_mtime(the_jnode);                                       
 200e530:	7f ff d4 4a 	call  2003658 <gettimeofday>                   
 200e534:	92 10 20 00 	clr  %o1                                       
 200e538:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200e53c:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        
  return 0;                                                           
}                                                                     
 200e540:	81 c7 e0 08 	ret                                            
 200e544:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

0200dcfc <IMFS_memfile_get_block_pointer>: #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) {
 200dcfc:	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 ) {                                  
 200dd00:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200dd04:	fa 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i5	! 201d1b8 <imfs_memfile_bytes_per_block>
 200dd08:	bb 37 60 02 	srl  %i5, 2, %i5                               
 200dd0c:	82 07 7f ff 	add  %i5, -1, %g1                              
 200dd10:	80 a6 40 01 	cmp  %i1, %g1                                  
 200dd14:	18 80 00 18 	bgu  200dd74 <IMFS_memfile_get_block_pointer+0x78>
 200dd18:	90 07 60 01 	add  %i5, 1, %o0                               
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
 200dd1c:	80 a6 a0 00 	cmp  %i2, 0                                    
 200dd20:	02 80 00 10 	be  200dd60 <IMFS_memfile_get_block_pointer+0x64>
 200dd24:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
                                                                      
      if ( !p ) {                                                     
 200dd28:	80 a0 60 00 	cmp  %g1, 0                                    
 200dd2c:	32 80 00 0a 	bne,a   200dd54 <IMFS_memfile_get_block_pointer+0x58>
 200dd30:	f0 06 20 58 	ld  [ %i0 + 0x58 ], %i0                        
        p = memfile_alloc_block();                                    
 200dd34:	7f ff ff e5 	call  200dcc8 <memfile_alloc_block>            
 200dd38:	01 00 00 00 	nop                                            
        if ( !p )                                                     
 200dd3c:	80 a2 20 00 	cmp  %o0, 0                                    
 200dd40:	32 80 00 04 	bne,a   200dd50 <IMFS_memfile_get_block_pointer+0x54><== ALWAYS TAKEN
 200dd44:	d0 26 20 58 	st  %o0, [ %i0 + 0x58 ]                        
           return 0;                                                  
 200dd48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200dd4c:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
        info->indirect = p;                                           
      }                                                               
      return &info->indirect[ my_block ];                             
 200dd50:	f0 06 20 58 	ld  [ %i0 + 0x58 ], %i0                        
 200dd54:	b3 2e 60 02 	sll  %i1, 2, %i1                               
 200dd58:	81 c7 e0 08 	ret                                            
 200dd5c:	91 ee 00 19 	restore  %i0, %i1, %o0                         
    }                                                                 
                                                                      
    if ( !p )                                                         
 200dd60:	80 a0 60 00 	cmp  %g1, 0                                    
 200dd64:	02 bf ff f9 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200dd68:	b3 2e 60 02 	sll  %i1, 2, %i1                               
      return 0;                                                       
                                                                      
    return &info->indirect[ my_block ];                               
 200dd6c:	81 c7 e0 08 	ret                                            
 200dd70:	91 e8 40 19 	restore  %g1, %i1, %o0                         
                                                                      
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
 200dd74:	40 00 29 a3 	call  2018400 <.umul>                          
 200dd78:	92 10 00 1d 	mov  %i5, %o1                                  
 200dd7c:	82 02 3f ff 	add  %o0, -1, %g1                              
 200dd80:	80 a6 40 01 	cmp  %i1, %g1                                  
 200dd84:	18 80 00 2c 	bgu  200de34 <IMFS_memfile_get_block_pointer+0x138>
 200dd88:	b8 10 00 08 	mov  %o0, %i4                                  
    my_block -= FIRST_DOUBLY_INDIRECT;                                
 200dd8c:	b2 26 40 1d 	sub  %i1, %i5, %i1                             
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
 200dd90:	92 10 00 1d 	mov  %i5, %o1                                  
 200dd94:	40 00 2a 81 	call  2018798 <.urem>                          
 200dd98:	90 10 00 19 	mov  %i1, %o0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
 200dd9c:	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;                     
 200dda0:	b8 10 00 08 	mov  %o0, %i4                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
 200dda4:	40 00 29 d1 	call  20184e8 <.udiv>                          
 200dda8:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
 200ddac:	80 a6 a0 00 	cmp  %i2, 0                                    
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
    my_block -= FIRST_DOUBLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
 200ddb0:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
 200ddb4:	02 80 00 17 	be  200de10 <IMFS_memfile_get_block_pointer+0x114>
 200ddb8:	d0 06 20 5c 	ld  [ %i0 + 0x5c ], %o0                        
                                                                      
      if ( !p ) {                                                     
 200ddbc:	80 a2 20 00 	cmp  %o0, 0                                    
 200ddc0:	12 80 00 08 	bne  200dde0 <IMFS_memfile_get_block_pointer+0xe4>
 200ddc4:	bb 2f 60 02 	sll  %i5, 2, %i5                               
        p = memfile_alloc_block();                                    
 200ddc8:	7f ff ff c0 	call  200dcc8 <memfile_alloc_block>            
 200ddcc:	01 00 00 00 	nop                                            
        if ( !p )                                                     
 200ddd0:	80 a2 20 00 	cmp  %o0, 0                                    
 200ddd4:	02 bf ff dd 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200ddd8:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->doubly_indirect = p;                                    
 200dddc:	d0 26 20 5c 	st  %o0, [ %i0 + 0x5c ]                        
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
 200dde0:	b6 02 00 1d 	add  %o0, %i5, %i3                             
 200dde4:	d0 02 00 1d 	ld  [ %o0 + %i5 ], %o0                         
      if ( !p1 ) {                                                    
 200dde8:	80 a2 20 00 	cmp  %o0, 0                                    
 200ddec:	12 80 00 4a 	bne  200df14 <IMFS_memfile_get_block_pointer+0x218>
 200ddf0:	b1 2f 20 02 	sll  %i4, 2, %i0                               
        p1 = memfile_alloc_block();                                   
 200ddf4:	7f ff ff b5 	call  200dcc8 <memfile_alloc_block>            
 200ddf8:	01 00 00 00 	nop                                            
        if ( !p1 )                                                    
 200ddfc:	80 a2 20 00 	cmp  %o0, 0                                    
 200de00:	02 bf ff d2 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200de04:	01 00 00 00 	nop                                            
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
 200de08:	10 80 00 43 	b  200df14 <IMFS_memfile_get_block_pointer+0x218>
 200de0c:	d0 26 c0 00 	st  %o0, [ %i3 ]                               
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
 200de10:	80 a2 20 00 	cmp  %o0, 0                                    
 200de14:	02 bf ff cd 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200de18:	bb 2f 60 02 	sll  %i5, 2, %i5                               
      return 0;                                                       
                                                                      
    p = (block_p *)p[ doubly ];                                       
 200de1c:	c2 02 00 1d 	ld  [ %o0 + %i5 ], %g1                         
    if ( !p )                                                         
 200de20:	80 a0 60 00 	cmp  %g1, 0                                    
 200de24:	02 bf ff c9 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200de28:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return (block_p *)&p[ singly ];                                   
 200de2c:	10 80 00 48 	b  200df4c <IMFS_memfile_get_block_pointer+0x250>
 200de30:	b1 2f 20 02 	sll  %i4, 2, %i0                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
 200de34:	90 02 20 01 	inc  %o0                                       
 200de38:	40 00 29 72 	call  2018400 <.umul>                          
 200de3c:	92 10 00 1d 	mov  %i5, %o1                                  
 200de40:	90 02 3f ff 	add  %o0, -1, %o0                              
 200de44:	80 a6 40 08 	cmp  %i1, %o0                                  
 200de48:	18 bf ff c0 	bgu  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200de4c:	b2 26 40 1c 	sub  %i1, %i4, %i1                             
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
 200de50:	92 10 00 1d 	mov  %i5, %o1                                  
 200de54:	40 00 2a 51 	call  2018798 <.urem>                          
 200de58:	90 10 00 19 	mov  %i1, %o0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
 200de5c:	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;                     
 200de60:	b6 10 00 08 	mov  %o0, %i3                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
 200de64:	40 00 29 a1 	call  20184e8 <.udiv>                          
 200de68:	90 10 00 19 	mov  %i1, %o0                                  
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
 200de6c:	92 10 00 1d 	mov  %i5, %o1                                  
 200de70:	40 00 29 9e 	call  20184e8 <.udiv>                          
 200de74:	b2 10 00 08 	mov  %o0, %i1                                  
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
 200de78:	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;                       
 200de7c:	b8 10 00 08 	mov  %o0, %i4                                  
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
 200de80:	40 00 2a 46 	call  2018798 <.urem>                          
 200de84:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
 200de88:	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;                               
 200de8c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
 200de90:	02 80 00 23 	be  200df1c <IMFS_memfile_get_block_pointer+0x220>
 200de94:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
      if ( !p ) {                                                     
 200de98:	80 a2 20 00 	cmp  %o0, 0                                    
 200de9c:	12 80 00 08 	bne  200debc <IMFS_memfile_get_block_pointer+0x1c0>
 200dea0:	b9 2f 20 02 	sll  %i4, 2, %i4                               
        p = memfile_alloc_block();                                    
 200dea4:	7f ff ff 89 	call  200dcc8 <memfile_alloc_block>            
 200dea8:	01 00 00 00 	nop                                            
        if ( !p )                                                     
 200deac:	80 a2 20 00 	cmp  %o0, 0                                    
 200deb0:	02 bf ff a6 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200deb4:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->triply_indirect = p;                                    
 200deb8:	d0 26 20 60 	st  %o0, [ %i0 + 0x60 ]                        
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
 200debc:	b4 02 00 1c 	add  %o0, %i4, %i2                             
 200dec0:	d0 02 00 1c 	ld  [ %o0 + %i4 ], %o0                         
      if ( !p1 ) {                                                    
 200dec4:	80 a2 20 00 	cmp  %o0, 0                                    
 200dec8:	12 80 00 08 	bne  200dee8 <IMFS_memfile_get_block_pointer+0x1ec>
 200decc:	bb 2f 60 02 	sll  %i5, 2, %i5                               
        p1 = memfile_alloc_block();                                   
 200ded0:	7f ff ff 7e 	call  200dcc8 <memfile_alloc_block>            
 200ded4:	01 00 00 00 	nop                                            
        if ( !p1 )                                                    
 200ded8:	80 a2 20 00 	cmp  %o0, 0                                    
 200dedc:	02 bf ff 9b 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200dee0:	01 00 00 00 	nop                                            
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
 200dee4:	d0 26 80 00 	st  %o0, [ %i2 ]                               
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
 200dee8:	b8 02 00 1d 	add  %o0, %i5, %i4                             
 200deec:	d0 02 00 1d 	ld  [ %o0 + %i5 ], %o0                         
      if ( !p2 ) {                                                    
 200def0:	80 a2 20 00 	cmp  %o0, 0                                    
 200def4:	12 80 00 08 	bne  200df14 <IMFS_memfile_get_block_pointer+0x218>
 200def8:	b1 2e e0 02 	sll  %i3, 2, %i0                               
        p2 = memfile_alloc_block();                                   
 200defc:	7f ff ff 73 	call  200dcc8 <memfile_alloc_block>            
 200df00:	01 00 00 00 	nop                                            
        if ( !p2 )                                                    
 200df04:	80 a2 20 00 	cmp  %o0, 0                                    
 200df08:	02 bf ff 90 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200df0c:	01 00 00 00 	nop                                            
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
 200df10:	d0 27 00 00 	st  %o0, [ %i4 ]                               
      }                                                               
      return (block_p *)&p2[ singly ];                                
 200df14:	81 c7 e0 08 	ret                                            
 200df18:	91 ea 00 18 	restore  %o0, %i0, %o0                         
    }                                                                 
                                                                      
    if ( !p )                                                         
 200df1c:	80 a2 20 00 	cmp  %o0, 0                                    
 200df20:	02 bf ff 8a 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200df24:	b9 2f 20 02 	sll  %i4, 2, %i4                               
      return 0;                                                       
                                                                      
    p1 = (block_p *) p[ triply ];                                     
 200df28:	c2 02 00 1c 	ld  [ %o0 + %i4 ], %g1                         
    if ( !p1 )                                                        
 200df2c:	80 a0 60 00 	cmp  %g1, 0                                    
 200df30:	02 bf ff 86 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200df34:	bb 2f 60 02 	sll  %i5, 2, %i5                               
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
 200df38:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1                         
    if ( !p2 )                                                        
 200df3c:	80 a0 60 00 	cmp  %g1, 0                                    
 200df40:	02 bf ff 82 	be  200dd48 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
 200df44:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
 200df48:	b1 2e e0 02 	sll  %i3, 2, %i0                               
                                                                      
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
  return 0;                                                           
}                                                                     
 200df4c:	81 c7 e0 08 	ret                                            
 200df50:	91 e8 40 18 	restore  %g1, %i0, %o0                         
                                                                      

0200df54 <IMFS_memfile_read>: IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) {
 200df54:	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;                                    
 200df58:	c2 06 20 4c 	ld  [ %i0 + 0x4c ], %g1                        
 200df5c:	ba 10 00 18 	mov  %i0, %i5                                  
   *  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 ) {                 
 200df60:	c2 00 40 00 	ld  [ %g1 ], %g1                               
   IMFS_jnode_t    *the_jnode,                                        
   off_t            start,                                            
   unsigned char   *destination,                                      
   unsigned int     length                                            
)                                                                     
{                                                                     
 200df64:	a0 10 00 19 	mov  %i1, %l0                                  
 200df68:	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 ) {                 
 200df6c:	80 a0 60 05 	cmp  %g1, 5                                    
 200df70:	12 80 00 17 	bne  200dfcc <IMFS_memfile_read+0x78>          
 200df74:	a4 10 00 1b 	mov  %i3, %l2                                  
    unsigned char  *file_ptr;                                         
                                                                      
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
 200df78:	f4 1e 20 50 	ldd  [ %i0 + 0x50 ], %i2                       
 200df7c:	82 10 20 00 	clr  %g1                                       
 200df80:	86 a6 c0 11 	subcc  %i3, %l1, %g3                           
 200df84:	84 66 80 19 	subx  %i2, %i1, %g2                            
 200df88:	80 a0 40 02 	cmp  %g1, %g2                                  
 200df8c:	14 80 00 07 	bg  200dfa8 <IMFS_memfile_read+0x54>           <== NEVER TAKEN
 200df90:	d2 06 20 58 	ld  [ %i0 + 0x58 ], %o1                        
 200df94:	80 a0 40 02 	cmp  %g1, %g2                                  
 200df98:	12 80 00 06 	bne  200dfb0 <IMFS_memfile_read+0x5c>          <== NEVER TAKEN
 200df9c:	80 a7 00 03 	cmp  %i4, %g3                                  
 200dfa0:	28 80 00 05 	bleu,a   200dfb4 <IMFS_memfile_read+0x60>      <== NEVER TAKEN
 200dfa4:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
      my_length = the_jnode->info.linearfile.size - start;            
 200dfa8:	10 80 00 03 	b  200dfb4 <IMFS_memfile_read+0x60>            
 200dfac:	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;                                                 
 200dfb0:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
    file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;    
                                                                      
    if (my_length > (the_jnode->info.linearfile.size - start))        
      my_length = the_jnode->info.linearfile.size - start;            
                                                                      
    memcpy(dest, &file_ptr[start], my_length);                        
 200dfb4:	90 10 00 12 	mov  %l2, %o0                                  
 200dfb8:	92 02 40 11 	add  %o1, %l1, %o1                             
 200dfbc:	40 00 07 fd 	call  200ffb0 <memcpy>                         
 200dfc0:	94 10 00 18 	mov  %i0, %o2                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
 200dfc4:	10 80 00 5d 	b  200e138 <IMFS_memfile_read+0x1e4>           
 200dfc8:	90 07 bf f8 	add  %fp, -8, %o0                              
  /*                                                                  
   *  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 )                        
 200dfcc:	c6 06 20 50 	ld  [ %i0 + 0x50 ], %g3                        
 200dfd0:	88 10 20 00 	clr  %g4                                       
                                                                      
  /*                                                                  
   *  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;                                         
 200dfd4:	82 10 00 1a 	mov  %i2, %g1                                  
  if ( last_byte > the_jnode->info.file.size )                        
 200dfd8:	c4 06 20 54 	ld  [ %i0 + 0x54 ], %g2                        
 200dfdc:	80 a1 00 03 	cmp  %g4, %g3                                  
 200dfe0:	14 80 00 08 	bg  200e000 <IMFS_memfile_read+0xac>           <== NEVER TAKEN
 200dfe4:	b6 07 00 1a 	add  %i4, %i2, %i3                             
 200dfe8:	80 a1 00 03 	cmp  %g4, %g3                                  
 200dfec:	32 80 00 07 	bne,a   200e008 <IMFS_memfile_read+0xb4>       <== NEVER TAKEN
 200dff0:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     <== NOT EXECUTED
 200dff4:	80 a6 c0 02 	cmp  %i3, %g2                                  
 200dff8:	28 80 00 04 	bleu,a   200e008 <IMFS_memfile_read+0xb4>      
 200dffc:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    my_length = the_jnode->info.file.size - start;                    
 200e000:	b8 20 80 01 	sub  %g2, %g1, %i4                             
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
 200e004:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200e008:	f6 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i3	! 201d1b8 <imfs_memfile_bytes_per_block>
 200e00c:	90 10 00 10 	mov  %l0, %o0                                  
 200e010:	b5 3e e0 1f 	sra  %i3, 0x1f, %i2                            
 200e014:	96 10 00 1b 	mov  %i3, %o3                                  
 200e018:	94 10 00 1a 	mov  %i2, %o2                                  
 200e01c:	40 00 2b 76 	call  2018df4 <__moddi3>                       
 200e020:	92 10 00 11 	mov  %l1, %o1                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
 200e024:	94 10 00 1a 	mov  %i2, %o2                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
 200e028:	a6 10 00 09 	mov  %o1, %l3                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
 200e02c:	90 10 00 10 	mov  %l0, %o0                                  
 200e030:	92 10 00 11 	mov  %l1, %o1                                  
 200e034:	40 00 2a 85 	call  2018a48 <__divdi3>                       
 200e038:	96 10 00 1b 	mov  %i3, %o3                                  
  if ( start_offset )  {                                              
 200e03c:	80 a4 e0 00 	cmp  %l3, 0                                    
 200e040:	02 80 00 18 	be  200e0a0 <IMFS_memfile_read+0x14c>          
 200e044:	b4 10 00 09 	mov  %o1, %i2                                  
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
 200e048:	b6 26 c0 13 	sub  %i3, %l3, %i3                             
 200e04c:	80 a7 00 1b 	cmp  %i4, %i3                                  
 200e050:	08 80 00 03 	bleu  200e05c <IMFS_memfile_read+0x108>        
 200e054:	b2 10 00 1c 	mov  %i4, %i1                                  
 200e058:	b2 10 00 1b 	mov  %i3, %i1                                  
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
 200e05c:	90 10 00 1d 	mov  %i5, %o0                                  
 200e060:	92 10 00 1a 	mov  %i2, %o1                                  
 200e064:	94 10 20 00 	clr  %o2                                       
 200e068:	7f ff ff 25 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e06c:	b0 10 20 00 	clr  %i0                                       
    if ( !block_ptr )                                                 
 200e070:	80 a2 20 00 	cmp  %o0, 0                                    
 200e074:	02 80 00 35 	be  200e148 <IMFS_memfile_read+0x1f4>          <== NEVER TAKEN
 200e078:	94 10 00 19 	mov  %i1, %o2                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
 200e07c:	d2 02 00 00 	ld  [ %o0 ], %o1                               
 200e080:	90 10 00 12 	mov  %l2, %o0                                  
 200e084:	92 02 40 13 	add  %o1, %l3, %o1                             
 200e088:	40 00 07 ca 	call  200ffb0 <memcpy>                         
 200e08c:	a4 04 80 19 	add  %l2, %i1, %l2                             
    dest += to_copy;                                                  
    block++;                                                          
 200e090:	b4 06 a0 01 	inc  %i2                                       
    my_length -= to_copy;                                             
 200e094:	b8 27 00 19 	sub  %i4, %i1, %i4                             
    copied += to_copy;                                                
 200e098:	10 80 00 03 	b  200e0a4 <IMFS_memfile_read+0x150>           
 200e09c:	b0 10 00 19 	mov  %i1, %i0                                  
   */                                                                 
  last_byte = start + length;                                         
  if ( last_byte > the_jnode->info.file.size )                        
    my_length = the_jnode->info.file.size - start;                    
                                                                      
  copied = 0;                                                         
 200e0a0:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
 200e0a4:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 *  is considered an error.  Read from an offset for more bytes than  
 *  are between the offset and the end of the file will result in     
 *  reading the data between offset and the end of the file (truncated
 *  read).                                                            
 */                                                                   
MEMFILE_STATIC ssize_t IMFS_memfile_read(                             
 200e0a8:	a4 24 80 18 	sub  %l2, %i0, %l2                             
  }                                                                   
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
 200e0ac:	f6 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i3                       
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
 200e0b0:	10 80 00 0f 	b  200e0ec <IMFS_memfile_read+0x198>           
 200e0b4:	a0 10 00 01 	mov  %g1, %l0                                  
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
 200e0b8:	90 10 00 1d 	mov  %i5, %o0                                  
 200e0bc:	92 10 00 1a 	mov  %i2, %o1                                  
 200e0c0:	7f ff ff 0f 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e0c4:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
 200e0c8:	82 92 20 00 	orcc  %o0, 0, %g1                              
 200e0cc:	02 80 00 1f 	be  200e148 <IMFS_memfile_read+0x1f4>          <== NEVER TAKEN
 200e0d0:	90 10 00 19 	mov  %i1, %o0                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
 200e0d4:	d2 00 40 00 	ld  [ %g1 ], %o1                               
 200e0d8:	94 10 00 1b 	mov  %i3, %o2                                  
 200e0dc:	40 00 07 b5 	call  200ffb0 <memcpy>                         
 200e0e0:	b4 06 a0 01 	inc  %i2                                       
    dest += to_copy;                                                  
    block++;                                                          
    my_length -= to_copy;                                             
 200e0e4:	b8 27 00 1b 	sub  %i4, %i3, %i4                             
    copied += to_copy;                                                
 200e0e8:	b0 06 00 1b 	add  %i0, %i3, %i0                             
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
 200e0ec:	c2 04 21 b8 	ld  [ %l0 + 0x1b8 ], %g1                       
 200e0f0:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e0f4:	1a bf ff f1 	bcc  200e0b8 <IMFS_memfile_read+0x164>         
 200e0f8:	b2 04 80 18 	add  %l2, %i0, %i1                             
  /*                                                                  
   *  Phase 3: possibly the first part of one block                   
   */                                                                 
  IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );            
                                                                      
  if ( my_length ) {                                                  
 200e0fc:	80 a7 20 00 	cmp  %i4, 0                                    
 200e100:	02 80 00 0e 	be  200e138 <IMFS_memfile_read+0x1e4>          
 200e104:	90 07 bf f8 	add  %fp, -8, %o0                              
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
 200e108:	90 10 00 1d 	mov  %i5, %o0                                  
 200e10c:	92 10 00 1a 	mov  %i2, %o1                                  
 200e110:	7f ff fe fb 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e114:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
 200e118:	82 92 20 00 	orcc  %o0, 0, %g1                              
 200e11c:	02 80 00 0b 	be  200e148 <IMFS_memfile_read+0x1f4>          <== NEVER TAKEN
 200e120:	90 10 00 19 	mov  %i1, %o0                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
 200e124:	d2 00 40 00 	ld  [ %g1 ], %o1                               
 200e128:	94 10 00 1c 	mov  %i4, %o2                                  
 200e12c:	40 00 07 a1 	call  200ffb0 <memcpy>                         
 200e130:	b0 07 00 18 	add  %i4, %i0, %i0                             
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
 200e134:	90 07 bf f8 	add  %fp, -8, %o0                              
 200e138:	7f ff d5 48 	call  2003658 <gettimeofday>                   
 200e13c:	92 10 20 00 	clr  %o1                                       
 200e140:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200e144:	c2 27 60 40 	st  %g1, [ %i5 + 0x40 ]                        
                                                                      
  return copied;                                                      
}                                                                     
 200e148:	81 c7 e0 08 	ret                                            
 200e14c:	81 e8 00 00 	restore                                        
                                                                      

0200e24c <IMFS_memfile_remove>: * is better to stick to simple, easy to understand algorithms. */ IMFS_jnode_t *IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) {
 200e24c:	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;                                 
 200e250:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200e254:	fa 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i5	! 201d1b8 <imfs_memfile_bytes_per_block>
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
 200e258:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
 200e25c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e260:	02 80 00 05 	be  200e274 <IMFS_memfile_remove+0x28>         
 200e264:	bb 37 60 02 	srl  %i5, 2, %i5                               
    memfile_free_blocks_in_table( &info->indirect, to_free );         
 200e268:	90 06 20 58 	add  %i0, 0x58, %o0                            
 200e26c:	7f ff ff e5 	call  200e200 <memfile_free_blocks_in_table>   
 200e270:	92 10 00 1d 	mov  %i5, %o1                                  
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
 200e274:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
 200e278:	b8 10 20 00 	clr  %i4                                       
 200e27c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e280:	12 80 00 0d 	bne  200e2b4 <IMFS_memfile_remove+0x68>        
 200e284:	37 00 80 74 	sethi  %hi(0x201d000), %i3                     
    }                                                                 
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
 200e288:	10 80 00 15 	b  200e2dc <IMFS_memfile_remove+0x90>          
 200e28c:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
 *         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(                                    
 200e290:	83 2f 20 02 	sll  %i4, 2, %g1                               
    memfile_free_blocks_in_table( &info->indirect, to_free );         
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      if ( info->doubly_indirect[i] ) {                               
 200e294:	90 00 80 01 	add  %g2, %g1, %o0                             
 200e298:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 200e29c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e2a0:	22 80 00 05 	be,a   200e2b4 <IMFS_memfile_remove+0x68>      <== NEVER TAKEN
 200e2a4:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
        memfile_free_blocks_in_table(                                 
 200e2a8:	7f ff ff d6 	call  200e200 <memfile_free_blocks_in_table>   
 200e2ac:	92 10 00 1d 	mov  %i5, %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++ ) {                  
 200e2b0:	b8 07 20 01 	inc  %i4                                       
 200e2b4:	c2 06 e1 b8 	ld  [ %i3 + 0x1b8 ], %g1                       
 200e2b8:	83 30 60 02 	srl  %g1, 2, %g1                               
 200e2bc:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e2c0:	2a bf ff f4 	bcs,a   200e290 <IMFS_memfile_remove+0x44>     
 200e2c4:	c4 06 20 5c 	ld  [ %i0 + 0x5c ], %g2                        
      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 );  
 200e2c8:	90 06 20 5c 	add  %i0, 0x5c, %o0                            
 200e2cc:	7f ff ff cd 	call  200e200 <memfile_free_blocks_in_table>   
 200e2d0:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
 200e2d4:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
 200e2d8:	b8 10 20 00 	clr  %i4                                       
 200e2dc:	80 a0 60 00 	cmp  %g1, 0                                    
 200e2e0:	12 80 00 1c 	bne  200e350 <IMFS_memfile_remove+0x104>       
 200e2e4:	33 00 80 74 	sethi  %hi(0x201d000), %i1                     
 200e2e8:	81 c7 e0 08 	ret                                            
 200e2ec:	81 e8 00 00 	restore                                        
 *         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(                                    
 200e2f0:	a1 2f 20 02 	sll  %i4, 2, %l0                               
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
 200e2f4:	f6 00 40 10 	ld  [ %g1 + %l0 ], %i3                         
      if ( !p )  /* ensure we have a valid pointer */                 
 200e2f8:	80 a6 e0 00 	cmp  %i3, 0                                    
 200e2fc:	02 80 00 1b 	be  200e368 <IMFS_memfile_remove+0x11c>        <== NEVER TAKEN
 200e300:	90 06 20 60 	add  %i0, 0x60, %o0                            
 200e304:	10 80 00 09 	b  200e328 <IMFS_memfile_remove+0xdc>          
 200e308:	b4 10 20 00 	clr  %i2                                       
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
        if ( p[j] ) {                                                 
 200e30c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e310:	02 80 00 04 	be  200e320 <IMFS_memfile_remove+0xd4>         <== NEVER TAKEN
 200e314:	90 10 00 1b 	mov  %i3, %o0                                  
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
 200e318:	7f ff ff ba 	call  200e200 <memfile_free_blocks_in_table>   
 200e31c:	92 10 00 1d 	mov  %i5, %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++ ) {                
 200e320:	b4 06 a0 01 	inc  %i2                                       
 200e324:	b6 06 e0 04 	add  %i3, 4, %i3                               
 200e328:	c2 06 61 b8 	ld  [ %i1 + 0x1b8 ], %g1                       
 200e32c:	83 30 60 02 	srl  %g1, 2, %g1                               
 200e330:	80 a6 80 01 	cmp  %i2, %g1                                  
 200e334:	2a bf ff f6 	bcs,a   200e30c <IMFS_memfile_remove+0xc0>     
 200e338:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
        if ( p[j] ) {                                                 
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
 200e33c:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
 200e340:	92 10 00 1d 	mov  %i5, %o1                                  
 200e344:	90 02 00 10 	add  %o0, %l0, %o0                             
 200e348:	7f ff ff ae 	call  200e200 <memfile_free_blocks_in_table>   
 200e34c:	b8 07 20 01 	inc  %i4                                       
    memfile_free_blocks_in_table( &info->doubly_indirect, to_free );  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
 200e350:	c2 06 61 b8 	ld  [ %i1 + 0x1b8 ], %g1                       
 200e354:	83 30 60 02 	srl  %g1, 2, %g1                               
 200e358:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e35c:	2a bf ff e5 	bcs,a   200e2f0 <IMFS_memfile_remove+0xa4>     
 200e360:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
        }                                                             
      }                                                               
      memfile_free_blocks_in_table(                                   
        (block_p **)&info->triply_indirect[i], to_free );             
    }                                                                 
    memfile_free_blocks_in_table(                                     
 200e364:	90 06 20 60 	add  %i0, 0x60, %o0                            
 200e368:	7f ff ff a6 	call  200e200 <memfile_free_blocks_in_table>   
 200e36c:	92 10 00 1d 	mov  %i5, %o1                                  
        (block_p **)&info->triply_indirect, to_free );                
  }                                                                   
                                                                      
  return the_jnode;                                                   
}                                                                     
 200e370:	81 c7 e0 08 	ret                                            
 200e374:	81 e8 00 00 	restore                                        
                                                                      

0200e378 <IMFS_memfile_remove_block>: */ MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) {
 200e378:	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 );  
 200e37c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 200e380:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 200e384:	7f ff fe 5e 	call  200dcfc <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
 200e388:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200e38c:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
  IMFS_assert( block_ptr );                                           
                                                                      
  ptr = *block_ptr;                                                   
 200e390:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
  *block_ptr = 0;                                                     
  memfile_free_block( ptr );                                          
                                                                      
  return 1;                                                           
}                                                                     
 200e394:	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 );                                          
 200e398:	7f ff ff 91 	call  200e1dc <memfile_free_block>             <== NOT EXECUTED
 200e39c:	c0 20 40 00 	clr  [ %g1 ]                                   <== NOT EXECUTED
                                                                      
  return 1;                                                           
}                                                                     
 200e3a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e3a4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200e548 <IMFS_memfile_write>: IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) {
 200e548:	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 ) {                      
 200e54c:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
 200e550:	86 10 20 00 	clr  %g3                                       
  /*                                                                  
   *  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;                                      
 200e554:	96 07 00 1a 	add  %i4, %i2, %o3                             
  if ( last_byte > the_jnode->info.file.size ) {                      
 200e558:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200e55c:	14 80 00 1b 	bg  200e5c8 <IMFS_memfile_write+0x80>          <== NEVER TAKEN
 200e560:	c4 06 20 54 	ld  [ %i0 + 0x54 ], %g2                        
 200e564:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200e568:	32 80 00 06 	bne,a   200e580 <IMFS_memfile_write+0x38>      <== NEVER TAKEN
 200e56c:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     <== NOT EXECUTED
 200e570:	80 a2 c0 02 	cmp  %o3, %g2                                  
 200e574:	18 80 00 16 	bgu  200e5cc <IMFS_memfile_write+0x84>         
 200e578:	80 a6 40 01 	cmp  %i1, %g1                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
 200e57c:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200e580:	fa 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i5	! 201d1b8 <imfs_memfile_bytes_per_block>
 200e584:	92 10 00 1a 	mov  %i2, %o1                                  
 200e588:	a3 3f 60 1f 	sra  %i5, 0x1f, %l1                            
 200e58c:	96 10 00 1d 	mov  %i5, %o3                                  
 200e590:	94 10 00 11 	mov  %l1, %o2                                  
 200e594:	40 00 2a 18 	call  2018df4 <__moddi3>                       
 200e598:	90 10 00 19 	mov  %i1, %o0                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
 200e59c:	90 10 00 19 	mov  %i1, %o0                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
 200e5a0:	a0 10 00 09 	mov  %o1, %l0                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
 200e5a4:	94 10 00 11 	mov  %l1, %o2                                  
 200e5a8:	92 10 00 1a 	mov  %i2, %o1                                  
 200e5ac:	40 00 29 27 	call  2018a48 <__divdi3>                       
 200e5b0:	96 10 00 1d 	mov  %i5, %o3                                  
  if ( start_offset )  {                                              
 200e5b4:	80 a4 20 00 	cmp  %l0, 0                                    
 200e5b8:	12 80 00 17 	bne  200e614 <IMFS_memfile_write+0xcc>         
 200e5bc:	b4 10 00 09 	mov  %o1, %i2                                  
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
    if ( status )                                                     
      return status;                                                  
  }                                                                   
                                                                      
  copied = 0;                                                         
 200e5c0:	10 80 00 28 	b  200e660 <IMFS_memfile_write+0x118>          
 200e5c4:	ba 10 20 00 	clr  %i5                                       
   *  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;               
 200e5c8:	80 a6 40 01 	cmp  %i1, %g1                                  <== NOT EXECUTED
 200e5cc:	14 80 00 09 	bg  200e5f0 <IMFS_memfile_write+0xa8>          <== NEVER TAKEN
 200e5d0:	92 10 20 01 	mov  1, %o1                                    
 200e5d4:	80 a6 40 01 	cmp  %i1, %g1                                  
 200e5d8:	32 80 00 06 	bne,a   200e5f0 <IMFS_memfile_write+0xa8>      <== NEVER TAKEN
 200e5dc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 200e5e0:	80 a6 80 02 	cmp  %i2, %g2                                  
 200e5e4:	18 80 00 04 	bgu  200e5f4 <IMFS_memfile_write+0xac>         
 200e5e8:	90 10 00 18 	mov  %i0, %o0                                  
 200e5ec:	92 10 20 00 	clr  %o1                                       
                                                                      
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
 200e5f0:	90 10 00 18 	mov  %i0, %o0                                  
 200e5f4:	92 0a 60 01 	and  %o1, 1, %o1                               
 200e5f8:	7f ff ff 6c 	call  200e3a8 <IMFS_memfile_extend>            
 200e5fc:	94 10 20 00 	clr  %o2                                       
    if ( status )                                                     
 200e600:	82 92 20 00 	orcc  %o0, 0, %g1                              
 200e604:	22 bf ff df 	be,a   200e580 <IMFS_memfile_write+0x38>       
 200e608:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
 200e60c:	81 c7 e0 08 	ret                                            
 200e610:	91 e8 00 01 	restore  %g0, %g1, %o0                         
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
  if ( start_offset )  {                                              
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
 200e614:	ba 27 40 10 	sub  %i5, %l0, %i5                             
 200e618:	80 a7 40 1c 	cmp  %i5, %i4                                  
 200e61c:	38 80 00 02 	bgu,a   200e624 <IMFS_memfile_write+0xdc>      
 200e620:	ba 10 00 1c 	mov  %i4, %i5                                  
    if ( to_copy > my_length )                                        
      to_copy = my_length;                                            
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
 200e624:	90 10 00 18 	mov  %i0, %o0                                  
 200e628:	92 10 00 1a 	mov  %i2, %o1                                  
 200e62c:	7f ff fd b4 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e630:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
 200e634:	80 a2 20 00 	cmp  %o0, 0                                    
 200e638:	02 80 00 36 	be  200e710 <IMFS_memfile_write+0x1c8>         <== NEVER TAKEN
 200e63c:	82 10 20 00 	clr  %g1                                       
        block,                                                        
        to_copy,                                                      
        src                                                           
      );                                                              
    #endif                                                            
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
 200e640:	d0 02 00 00 	ld  [ %o0 ], %o0                               
 200e644:	92 10 00 1b 	mov  %i3, %o1                                  
 200e648:	90 02 00 10 	add  %o0, %l0, %o0                             
 200e64c:	94 10 00 1d 	mov  %i5, %o2                                  
 200e650:	40 00 06 58 	call  200ffb0 <memcpy>                         
 200e654:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
    src += to_copy;                                                   
    block++;                                                          
 200e658:	b4 06 a0 01 	inc  %i2                                       
    my_length -= to_copy;                                             
 200e65c:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
 200e660:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 *  IMFS_memfile_write                                                
 *                                                                    
 *  This routine writes the specified data buffer into the in memory  
 *  file pointed to by the_jnode.  The file is extended as needed.    
 */                                                                   
MEMFILE_STATIC ssize_t IMFS_memfile_write(                            
 200e664:	b6 26 c0 1d 	sub  %i3, %i5, %i3                             
                                                                      
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
 200e668:	f2 00 61 b8 	ld  [ %g1 + 0x1b8 ], %i1                       
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
 200e66c:	10 80 00 0f 	b  200e6a8 <IMFS_memfile_write+0x160>          
 200e670:	a2 10 00 01 	mov  %g1, %l1                                  
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
 200e674:	90 10 00 18 	mov  %i0, %o0                                  
 200e678:	92 10 00 1a 	mov  %i2, %o1                                  
 200e67c:	7f ff fd a0 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e680:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
 200e684:	80 a2 20 00 	cmp  %o0, 0                                    
 200e688:	02 80 00 21 	be  200e70c <IMFS_memfile_write+0x1c4>         <== NEVER TAKEN
 200e68c:	94 10 00 19 	mov  %i1, %o2                                  
      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 );                       
 200e690:	d0 02 00 00 	ld  [ %o0 ], %o0                               
 200e694:	92 10 00 10 	mov  %l0, %o1                                  
 200e698:	40 00 06 46 	call  200ffb0 <memcpy>                         
 200e69c:	b4 06 a0 01 	inc  %i2                                       
    src += to_copy;                                                   
    block++;                                                          
    my_length -= to_copy;                                             
 200e6a0:	b8 27 00 19 	sub  %i4, %i1, %i4                             
 *  IMFS_memfile_write                                                
 *                                                                    
 *  This routine writes the specified data buffer into the in memory  
 *  file pointed to by the_jnode.  The file is extended as needed.    
 */                                                                   
MEMFILE_STATIC ssize_t IMFS_memfile_write(                            
 200e6a4:	ba 07 40 19 	add  %i5, %i1, %i5                             
  /*                                                                  
   *  Phase 2: all of zero of more blocks                             
   */                                                                 
                                                                      
  to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;                             
  while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {               
 200e6a8:	c2 04 61 b8 	ld  [ %l1 + 0x1b8 ], %g1                       
 200e6ac:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e6b0:	1a bf ff f1 	bcc  200e674 <IMFS_memfile_write+0x12c>        
 200e6b4:	a0 06 c0 1d 	add  %i3, %i5, %l0                             
   *  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 ) {                                                  
 200e6b8:	80 a7 20 00 	cmp  %i4, 0                                    
 200e6bc:	02 80 00 0f 	be  200e6f8 <IMFS_memfile_write+0x1b0>         
 200e6c0:	90 07 bf f8 	add  %fp, -8, %o0                              
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
 200e6c4:	90 10 00 18 	mov  %i0, %o0                                  
 200e6c8:	92 10 00 1a 	mov  %i2, %o1                                  
 200e6cc:	7f ff fd 8c 	call  200dcfc <IMFS_memfile_get_block_pointer> 
 200e6d0:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
 200e6d4:	80 a2 20 00 	cmp  %o0, 0                                    
 200e6d8:	02 80 00 0e 	be  200e710 <IMFS_memfile_write+0x1c8>         <== NEVER TAKEN
 200e6dc:	82 10 00 1d 	mov  %i5, %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 );                     
 200e6e0:	d0 02 00 00 	ld  [ %o0 ], %o0                               
 200e6e4:	92 10 00 10 	mov  %l0, %o1                                  
 200e6e8:	94 10 00 1c 	mov  %i4, %o2                                  
 200e6ec:	40 00 06 31 	call  200ffb0 <memcpy>                         
 200e6f0:	ba 07 40 1c 	add  %i5, %i4, %i5                             
    my_length = 0;                                                    
    copied += to_copy;                                                
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
 200e6f4:	90 07 bf f8 	add  %fp, -8, %o0                              
 200e6f8:	7f ff d3 d8 	call  2003658 <gettimeofday>                   
 200e6fc:	92 10 20 00 	clr  %o1                                       
 200e700:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200e704:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        
 200e708:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
   */                                                                 
                                                                      
  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 )                                                 
 200e70c:	82 10 00 1d 	mov  %i5, %g1                                  
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
 200e710:	b0 10 00 01 	mov  %g1, %i0                                  
 200e714:	81 c7 e0 08 	ret                                            
 200e718:	81 e8 00 00 	restore                                        
                                                                      

02002e20 <IMFS_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
 2002e20:	9d e3 bf 80 	save  %sp, -128, %sp                           
  dev_t dev,                                                          
  IMFS_jnode_types_t *type,                                           
  IMFS_types_union *info                                              
)                                                                     
{                                                                     
  if ( S_ISDIR( mode ) ) {                                            
 2002e24:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
 2002e28:	07 00 00 10 	sethi  %hi(0x4000), %g3                        
 2002e2c:	84 0e c0 02 	and  %i3, %g2, %g2                             
 2002e30:	80 a0 80 03 	cmp  %g2, %g3                                  
 2002e34:	02 80 00 12 	be  2002e7c <IMFS_mknod+0x5c>                  
 2002e38:	07 00 00 20 	sethi  %hi(0x8000), %g3                        
    *type = IMFS_DIRECTORY;                                           
  } else if ( S_ISREG( mode ) ) {                                     
 2002e3c:	80 a0 80 03 	cmp  %g2, %g3                                  
 2002e40:	02 80 00 11 	be  2002e84 <IMFS_mknod+0x64>                  
 2002e44:	09 00 00 2c 	sethi  %hi(0xb000), %g4                        
    *type = IMFS_MEMORY_FILE;                                         
  } else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {                  
 2002e48:	07 00 00 08 	sethi  %hi(0x2000), %g3                        
 2002e4c:	88 0e c0 04 	and  %i3, %g4, %g4                             
 2002e50:	80 a1 00 03 	cmp  %g4, %g3                                  
 2002e54:	12 80 00 05 	bne  2002e68 <IMFS_mknod+0x48>                 
 2002e58:	07 00 00 04 	sethi  %hi(0x1000), %g3                        
    *type = IMFS_DEVICE;                                              
    rtems_filesystem_split_dev_t(                                     
 2002e5c:	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;                                              
 2002e60:	10 80 00 0a 	b  2002e88 <IMFS_mknod+0x68>                   
 2002e64:	82 10 20 01 	mov  1, %g1                                    
    rtems_filesystem_split_dev_t(                                     
      dev,                                                            
      info->device.major,                                             
      info->device.minor                                              
    );                                                                
  } else if (S_ISFIFO( mode )) {                                      
 2002e68:	80 a0 80 03 	cmp  %g2, %g3                                  
 2002e6c:	32 80 00 08 	bne,a   2002e8c <IMFS_mknod+0x6c>              <== NEVER TAKEN
 2002e70:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        <== NOT EXECUTED
    *type = IMFS_FIFO;                                                
 2002e74:	10 80 00 05 	b  2002e88 <IMFS_mknod+0x68>                   
 2002e78:	82 10 20 06 	mov  6, %g1                                    
  IMFS_jnode_types_t *type,                                           
  IMFS_types_union *info                                              
)                                                                     
{                                                                     
  if ( S_ISDIR( mode ) ) {                                            
    *type = IMFS_DIRECTORY;                                           
 2002e7c:	10 80 00 03 	b  2002e88 <IMFS_mknod+0x68>                   
 2002e80:	82 10 20 00 	clr  %g1                                       
 2002e84:	82 10 20 04 	mov  4, %g1                                    
  size_t namelen,                                                     
  mode_t mode,                                                        
  const IMFS_types_union *info                                        
)                                                                     
{                                                                     
  const IMFS_fs_info_t *fs_info =                                     
 2002e88:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
    (const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;            
                                                                      
  return IMFS_create_node_with_control(                               
 2002e8c:	82 00 60 02 	add  %g1, 2, %g1                               
 2002e90:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
 2002e94:	83 28 60 02 	sll  %g1, 2, %g1                               
 2002e98:	d2 00 80 01 	ld  [ %g2 + %g1 ], %o1                         
 2002e9c:	90 10 00 18 	mov  %i0, %o0                                  
 2002ea0:	94 10 00 19 	mov  %i1, %o2                                  
 2002ea4:	96 10 00 1a 	mov  %i2, %o3                                  
 2002ea8:	98 10 00 1b 	mov  %i3, %o4                                  
 2002eac:	40 00 22 1e 	call  200b724 <IMFS_create_node_with_control>  
 2002eb0:	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 ) {                                           
 2002eb4:	80 a2 20 00 	cmp  %o0, 0                                    
 2002eb8:	02 80 00 0e 	be  2002ef0 <IMFS_mknod+0xd0>                  
 2002ebc:	90 07 bf e0 	add  %fp, -32, %o0                             
    IMFS_jnode_t *parent = parentloc->node_access;                    
 2002ec0:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
    IMFS_update_ctime( parent );                                      
 2002ec4:	40 00 01 e5 	call  2003658 <gettimeofday>                   
 2002ec8:	92 10 20 00 	clr  %o1                                       
 2002ecc:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
    IMFS_update_mtime( parent );                                      
 2002ed0:	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 );                                      
 2002ed4:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
    IMFS_update_mtime( parent );                                      
 2002ed8:	40 00 01 e0 	call  2003658 <gettimeofday>                   
 2002edc:	92 10 20 00 	clr  %o1                                       
 2002ee0:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
 2002ee4:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
  size_t namelen,                                                     
  mode_t mode,                                                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
 2002ee8:	81 c7 e0 08 	ret                                            
 2002eec:	91 e8 20 00 	restore  %g0, 0, %o0                           
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2002ef0:	81 c7 e0 08 	ret                                            
 2002ef4:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

02002ef8 <IMFS_mount>: #endif #include "imfs.h" int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
 2002ef8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access; 
 2002efc:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
 2002f00:	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;                  
 2002f04:	c4 00 60 4c 	ld  [ %g1 + 0x4c ], %g2                        
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
 2002f08:	c4 00 80 00 	ld  [ %g2 ], %g2                               
 2002f0c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2002f10:	12 80 00 0d 	bne  2002f44 <IMFS_mount+0x4c>                 
 2002f14:	01 00 00 00 	nop                                            
    if ( node->info.directory.mt_fs == NULL ) {                       
 2002f18:	c4 00 60 5c 	ld  [ %g1 + 0x5c ], %g2                        
 2002f1c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2002f20:	12 80 00 05 	bne  2002f34 <IMFS_mount+0x3c>                 <== NEVER TAKEN
 2002f24:	01 00 00 00 	nop                                            
      node->info.directory.mt_fs = mt_entry;                          
 2002f28:	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;                                                         
 2002f2c:	81 c7 e0 08 	ret                                            
 2002f30:	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;                                                  
 2002f34:	40 00 31 ce 	call  200f66c <__errno>                        <== NOT EXECUTED
 2002f38:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2002f3c:	10 80 00 05 	b  2002f50 <IMFS_mount+0x58>                   <== NOT EXECUTED
 2002f40:	82 10 20 10 	mov  0x10, %g1	! 10 <PROM_START+0x10>          <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOTDIR;                                                  
 2002f44:	40 00 31 ca 	call  200f66c <__errno>                        
 2002f48:	01 00 00 00 	nop                                            
 2002f4c:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          
 2002f50:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2002f54:	81 c7 e0 08 	ret                                            
 2002f58:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

0200bb74 <IMFS_node_remove_directory>: } static IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node ) {
 200bb74:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {     
 200bb78:	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 );                            
 200bb7c:	82 06 20 54 	add  %i0, 0x54, %g1                            
 200bb80:	80 a0 80 01 	cmp  %g2, %g1                                  
 200bb84:	22 80 00 06 	be,a   200bb9c <IMFS_node_remove_directory+0x28>
 200bb88:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
    errno = ENOTEMPTY;                                                
 200bb8c:	40 00 0e b8 	call  200f66c <__errno>                        
 200bb90:	01 00 00 00 	nop                                            
 200bb94:	10 80 00 08 	b  200bbb4 <IMFS_node_remove_directory+0x40>   
 200bb98:	82 10 20 5a 	mov  0x5a, %g1	! 5a <PROM_START+0x5a>          
    node = NULL;                                                      
  } else if ( IMFS_is_mount_point( node ) ) {                         
 200bb9c:	80 a0 60 00 	cmp  %g1, 0                                    
 200bba0:	02 80 00 07 	be  200bbbc <IMFS_node_remove_directory+0x48>  <== ALWAYS TAKEN
 200bba4:	01 00 00 00 	nop                                            
    errno = EBUSY;                                                    
 200bba8:	40 00 0e b1 	call  200f66c <__errno>                        <== NOT EXECUTED
 200bbac:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200bbb0:	82 10 20 10 	mov  0x10, %g1	! 10 <PROM_START+0x10>          <== NOT EXECUTED
 200bbb4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200bbb8:	b0 10 20 00 	clr  %i0                                       
    node = NULL;                                                      
  }                                                                   
                                                                      
  return node;                                                        
}                                                                     
 200bbbc:	81 c7 e0 08 	ret                                            
 200bbc0:	81 e8 00 00 	restore                                        
                                                                      

02002f5c <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;
 2002f5c:	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;                                    
 2002f60:	c2 00 a0 4c 	ld  [ %g2 + 0x4c ], %g1                        
 2002f64:	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 ) {                                              
 2002f68:	80 a0 60 02 	cmp  %g1, 2                                    
 2002f6c:	02 80 00 06 	be  2002f84 <IMFS_node_type+0x28>              
 2002f70:	80 a0 60 05 	cmp  %g1, 5                                    
 2002f74:	12 80 00 08 	bne  2002f94 <IMFS_node_type+0x38>             <== ALWAYS TAKEN
 2002f78:	90 10 20 04 	mov  4, %o0                                    
 2002f7c:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2002f80:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2002f84:	c2 00 a0 50 	ld  [ %g2 + 0x50 ], %g1                        
 2002f88:	c2 00 60 4c 	ld  [ %g1 + 0x4c ], %g1                        
    case IMFS_HARD_LINK:                                              
      type = IMFS_type( node->info.hard_link.link_node );             
      break;                                                          
 2002f8c:	81 c3 e0 08 	retl                                           
 2002f90:	d0 00 40 00 	ld  [ %g1 ], %o0                               
      type = imfs_type;                                               
      break;                                                          
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
 2002f94:	81 c3 e0 08 	retl                                           
 2002f98:	90 10 00 01 	mov  %g1, %o0                                  
                                                                      

02002fd8 <IMFS_rename>: const rtems_filesystem_location_info_t *oldloc, const rtems_filesystem_location_info_t *newparentloc, const char *name, size_t namelen ) {
 2002fd8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int rv = 0;                                                         
  IMFS_jnode_t *node = oldloc->node_access;                           
 2002fdc:	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 ) {                                       
 2002fe0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 2002fe4:	80 a0 60 00 	cmp  %g1, 0                                    
 2002fe8:	02 80 00 20 	be  2003068 <IMFS_rename+0x90>                 <== NEVER TAKEN
 2002fec:	f4 06 a0 08 	ld  [ %i2 + 8 ], %i2                           
    if ( namelen < IMFS_NAME_MAX ) {                                  
 2002ff0:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
 2002ff4:	18 80 00 19 	bgu  2003058 <IMFS_rename+0x80>                <== NEVER TAKEN
 2002ff8:	94 10 00 1c 	mov  %i4, %o2                                  
      memcpy( node->name, name, namelen );                            
 2002ffc:	92 10 00 1b 	mov  %i3, %o1                                  
 2003000:	40 00 33 ec 	call  200ffb0 <memcpy>                         
 2003004:	90 07 60 0c 	add  %i5, 0xc, %o0                             
      node->name [namelen] = '\0';                                    
 2003008:	b8 07 40 1c 	add  %i5, %i4, %i4                             
 200300c:	c0 2f 20 0c 	clrb  [ %i4 + 0xc ]                            
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 2003010:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
 2003014:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
                                                                      
      IMFS_remove_from_directory( node );                             
      IMFS_add_to_directory( new_parent, node );                      
      IMFS_update_ctime( node );                                      
 2003018:	90 07 bf f8 	add  %fp, -8, %o0                              
  next->previous = previous;                                          
 200301c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 2003020:	c4 20 40 00 	st  %g2, [ %g1 ]                               
static inline void IMFS_add_to_directory(                             
  IMFS_jnode_t *dir,                                                  
  IMFS_jnode_t *node                                                  
)                                                                     
{                                                                     
  node->Parent = dir;                                                 
 2003024:	f4 27 60 08 	st  %i2, [ %i5 + 8 ]                           
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 2003028:	c2 06 a0 58 	ld  [ %i2 + 0x58 ], %g1                        
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(                  
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
 200302c:	84 06 a0 54 	add  %i2, 0x54, %g2                            
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
 2003030:	fa 26 a0 58 	st  %i5, [ %i2 + 0x58 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 2003034:	c4 27 40 00 	st  %g2, [ %i5 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 2003038:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  the_node->previous = old_last;                                      
 200303c:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
 2003040:	40 00 01 86 	call  2003658 <gettimeofday>                   
 2003044:	92 10 20 00 	clr  %o1                                       
 2003048:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200304c:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
  const rtems_filesystem_location_info_t *newparentloc,               
  const char *name,                                                   
  size_t namelen                                                      
)                                                                     
{                                                                     
  int rv = 0;                                                         
 2003050:	81 c7 e0 08 	ret                                            
 2003054:	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;                                           
 2003058:	40 00 31 85 	call  200f66c <__errno>                        <== NOT EXECUTED
 200305c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2003060:	10 80 00 05 	b  2003074 <IMFS_rename+0x9c>                  <== NOT EXECUTED
 2003064:	82 10 20 5b 	mov  0x5b, %g1	! 5b <PROM_START+0x5b>          <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
 2003068:	40 00 31 81 	call  200f66c <__errno>                        <== NOT EXECUTED
 200306c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2003070:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
 2003074:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2003078:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200307c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

02003158 <IMFS_unmount>: #endif #include "imfs.h" int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
 2003158:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access; 
 200315c:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
 2003160:	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;                  
 2003164:	c4 00 60 4c 	ld  [ %g1 + 0x4c ], %g2                        
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
 2003168:	c4 00 80 00 	ld  [ %g2 ], %g2                               
 200316c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2003170:	12 80 00 0d 	bne  20031a4 <IMFS_unmount+0x4c>               <== NEVER TAKEN
 2003174:	01 00 00 00 	nop                                            
    if ( node->info.directory.mt_fs == mt_entry ) {                   
 2003178:	c4 00 60 5c 	ld  [ %g1 + 0x5c ], %g2                        
 200317c:	80 a0 80 18 	cmp  %g2, %i0                                  
 2003180:	12 80 00 05 	bne  2003194 <IMFS_unmount+0x3c>               <== NEVER TAKEN
 2003184:	01 00 00 00 	nop                                            
      node->info.directory.mt_fs = NULL;                              
 2003188:	c0 20 60 5c 	clr  [ %g1 + 0x5c ]                            
                                                                      
#include "imfs.h"                                                     
                                                                      
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )    
{                                                                     
  int rv = 0;                                                         
 200318c:	81 c7 e0 08 	ret                                            
 2003190:	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;                                                 
 2003194:	40 00 31 36 	call  200f66c <__errno>                        <== NOT EXECUTED
 2003198:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200319c:	10 80 00 05 	b  20031b0 <IMFS_unmount+0x58>                 <== NOT EXECUTED
 20031a0:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOTDIR;                                                  
 20031a4:	40 00 31 32 	call  200f66c <__errno>                        <== NOT EXECUTED
 20031a8:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20031ac:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          <== NOT EXECUTED
 20031b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 20031b4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20031b8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

02003844 <RTEMS_Malloc_Initialize>: void RTEMS_Malloc_Initialize( const Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) {
 2003844:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Control *heap = RTEMS_Malloc_Heap;                             
 2003848:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 200384c:	f6 00 61 b0 	ld  [ %g1 + 0x1b0 ], %i3	! 201c9b0 <RTEMS_Malloc_Heap>
                                                                      
  if ( !rtems_configuration_get_unified_work_area() ) {               
 2003850:	03 00 80 69 	sethi  %hi(0x201a400), %g1                     
 2003854:	c2 08 63 a9 	ldub  [ %g1 + 0x3a9 ], %g1	! 201a7a9 <Configuration+0x31>
 2003858:	80 a0 60 00 	cmp  %g1, 0                                    
 200385c:	12 80 00 1b 	bne  20038c8 <RTEMS_Malloc_Initialize+0x84>    
 2003860:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 2003864:	3b 00 80 22 	sethi  %hi(0x2008800), %i5                     
 2003868:	b8 10 20 00 	clr  %i4                                       
 200386c:	10 80 00 0b 	b  2003898 <RTEMS_Malloc_Initialize+0x54>      
 2003870:	ba 17 60 b0 	or  %i5, 0xb0, %i5                             
    uintptr_t page_size = CPU_HEAP_ALIGNMENT;                         
    size_t i;                                                         
                                                                      
    for (i = 0; i < area_count; ++i) {                                
      const Heap_Area *area = &areas [i];                             
      uintptr_t space_available = (*init_or_extend)(                  
 2003874:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
 2003878:	90 10 00 1b 	mov  %i3, %o0                                  
 200387c:	9f c7 40 00 	call  %i5                                      
 2003880:	96 10 20 08 	mov  8, %o3                                    
        area->begin,                                                  
        area->size,                                                   
        page_size                                                     
      );                                                              
                                                                      
      if ( space_available > 0 ) {                                    
 2003884:	80 a2 20 00 	cmp  %o0, 0                                    
 2003888:	32 80 00 02 	bne,a   2003890 <RTEMS_Malloc_Initialize+0x4c> <== ALWAYS TAKEN
 200388c:	ba 10 00 1a 	mov  %i2, %i5                                  
  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) {                                
 2003890:	b8 07 20 01 	inc  %i4                                       
 2003894:	b0 06 20 08 	add  %i0, 8, %i0                               
 2003898:	80 a7 00 19 	cmp  %i4, %i1                                  
 200389c:	32 bf ff f6 	bne,a   2003874 <RTEMS_Malloc_Initialize+0x30> 
 20038a0:	d2 06 00 00 	ld  [ %i0 ], %o1                               
      if ( space_available > 0 ) {                                    
        init_or_extend = extend;                                      
      }                                                               
    }                                                                 
                                                                      
    if ( init_or_extend == _Heap_Initialize ) {                       
 20038a4:	03 00 80 22 	sethi  %hi(0x2008800), %g1                     
 20038a8:	82 10 60 b0 	or  %g1, 0xb0, %g1	! 20088b0 <_Heap_Initialize>
 20038ac:	80 a7 40 01 	cmp  %i5, %g1                                  
 20038b0:	12 80 00 06 	bne  20038c8 <RTEMS_Malloc_Initialize+0x84>    
 20038b4:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
      _Internal_error_Occurred(                                       
 20038b8:	90 10 20 00 	clr  %o0                                       
 20038bc:	92 10 20 01 	mov  1, %o1                                    
 20038c0:	40 00 14 8f 	call  2008afc <_Internal_error_Occurred>       
 20038c4:	94 10 20 17 	mov  0x17, %o2                                 
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, initialize the statistics support                
   */                                                                 
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
 20038c8:	c2 00 61 90 	ld  [ %g1 + 0x190 ], %g1                       
 20038cc:	80 a0 60 00 	cmp  %g1, 0                                    
 20038d0:	02 80 00 05 	be  20038e4 <RTEMS_Malloc_Initialize+0xa0>     
 20038d4:	3b 00 80 75 	sethi  %hi(0x201d400), %i5                     
    (*rtems_malloc_statistics_helpers->initialize)();                 
 20038d8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 20038dc:	9f c0 40 00 	call  %g1                                      
 20038e0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  MSBUMP( space_available, _Protected_heap_Get_size( heap ) );        
 20038e4:	f8 07 60 50 	ld  [ %i5 + 0x50 ], %i4                        
 20038e8:	40 00 16 dd 	call  200945c <_Protected_heap_Get_size>       
 20038ec:	90 10 00 1b 	mov  %i3, %o0                                  
 20038f0:	90 02 00 1c 	add  %o0, %i4, %o0                             
 20038f4:	d0 27 60 50 	st  %o0, [ %i5 + 0x50 ]                        
 20038f8:	81 c7 e0 08 	ret                                            
 20038fc:	81 e8 00 00 	restore                                        
                                                                      

020224b8 <Stack_check_Dump_threads_usage>: static rtems_printk_plugin_t print_handler; static void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) {
 20224b8:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Obtain interrupt stack information                              
   */                                                                 
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if (the_thread == (Thread_Control *) -1) {                        
 20224bc:	80 a6 3f ff 	cmp  %i0, -1                                   
 20224c0:	32 80 00 0a 	bne,a   20224e8 <Stack_check_Dump_threads_usage+0x30>
 20224c4:	e0 06 21 40 	ld  [ %i0 + 0x140 ], %l0                       
      if (!Stack_check_Interrupt_stack.area)                          
 20224c8:	3b 00 81 8a 	sethi  %hi(0x2062800), %i5                     
 20224cc:	ba 17 62 9c 	or  %i5, 0x29c, %i5	! 2062a9c <Stack_check_Interrupt_stack>
 20224d0:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 20224d4:	80 a0 60 00 	cmp  %g1, 0                                    
 20224d8:	02 80 00 4c 	be  2022608 <Stack_check_Dump_threads_usage+0x150><== NEVER TAKEN
 20224dc:	a0 10 20 00 	clr  %l0                                       
        return;                                                       
      stack = &Stack_check_Interrupt_stack;                           
      the_thread = 0;                                                 
 20224e0:	10 80 00 04 	b  20224f0 <Stack_check_Dump_threads_usage+0x38>
 20224e4:	b0 10 20 00 	clr  %i0                                       
      current = 0;                                                    
    } else                                                            
  #endif                                                              
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
 20224e8:	ba 06 20 b4 	add  %i0, 0xb4, %i5                            
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
 20224ec:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  size = Stack_check_usable_stack_size(stack);                        
 20224f0:	f2 07 40 00 	ld  [ %i5 ], %i1                               
    {                                                                 
      stack  = &the_thread->Start.Initial_stack;                      
      current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
 20224f4:	84 00 60 10 	add  %g1, 0x10, %g2                            
  size = Stack_check_usable_stack_size(stack);                        
 20224f8:	b2 06 7f f0 	add  %i1, -16, %i1                             
    /*                                                                
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
 20224fc:	82 00 60 20 	add  %g1, 0x20, %g1                            
    for (ebase = base + length; base < ebase; base++)                 
 2022500:	86 0e 7f fc 	and  %i1, -4, %g3                              
      if (*base != U32_PATTERN)                                       
 2022504:	09 29 69 69 	sethi  %hi(0xa5a5a400), %g4                    
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
 2022508:	86 00 40 03 	add  %g1, %g3, %g3                             
      if (*base != U32_PATTERN)                                       
 202250c:	10 80 00 06 	b  2022524 <Stack_check_Dump_threads_usage+0x6c>
 2022510:	88 11 21 a5 	or  %g4, 0x1a5, %g4                            
 2022514:	80 a7 00 04 	cmp  %i4, %g4                                  
 2022518:	12 80 00 08 	bne  2022538 <Stack_check_Dump_threads_usage+0x80>
 202251c:	80 a0 60 00 	cmp  %g1, 0                                    
     * start at lower memory and find first word that does not        
     * match pattern                                                  
     */                                                               
                                                                      
    base += PATTERN_SIZE_WORDS;                                       
    for (ebase = base + length; base < ebase; base++)                 
 2022520:	82 00 60 04 	add  %g1, 4, %g1                               
 2022524:	80 a0 40 03 	cmp  %g1, %g3                                  
 2022528:	2a bf ff fb 	bcs,a   2022514 <Stack_check_Dump_threads_usage+0x5c><== ALWAYS TAKEN
 202252c:	f8 00 40 00 	ld  [ %g1 ], %i4                               
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
                                                                      
  if ( high_water_mark )                                              
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
  else                                                                
    used = 0;                                                         
 2022530:	10 80 00 06 	b  2022548 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
 2022534:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  low  = Stack_check_usable_stack_start(stack);                       
  size = Stack_check_usable_stack_size(stack);                        
                                                                      
  high_water_mark = Stack_check_find_high_water_mark(low, size);      
                                                                      
  if ( high_water_mark )                                              
 2022538:	02 80 00 04 	be  2022548 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
 202253c:	b8 10 20 00 	clr  %i4                                       
    used = Stack_check_Calculate_used( low, size, high_water_mark );  
 2022540:	b8 00 80 19 	add  %g2, %i1, %i4                             
 2022544:	b8 27 00 01 	sub  %i4, %g1, %i4                             
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
 2022548:	80 a6 20 00 	cmp  %i0, 0                                    
 202254c:	02 80 00 12 	be  2022594 <Stack_check_Dump_threads_usage+0xdc>
 2022550:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
  #endif                                                              
    {                                                                 
      (*print_handler)(                                               
 2022554:	f6 06 20 08 	ld  [ %i0 + 8 ], %i3                           
 2022558:	f4 00 60 a8 	ld  [ %g1 + 0xa8 ], %i2                        
 202255c:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 2022560:	e2 00 60 a4 	ld  [ %g1 + 0xa4 ], %l1	! 20618a4 <print_context>
 2022564:	94 07 bf f8 	add  %fp, -8, %o2                              
 2022568:	90 10 00 1b 	mov  %i3, %o0                                  
 202256c:	7f ff b2 49 	call  200ee90 <rtems_object_get_name>          
 2022570:	92 10 20 05 	mov  5, %o1                                    
 2022574:	13 00 81 61 	sethi  %hi(0x2058400), %o1                     
 2022578:	96 10 00 08 	mov  %o0, %o3                                  
 202257c:	92 12 63 f0 	or  %o1, 0x3f0, %o1                            
 2022580:	90 10 00 11 	mov  %l1, %o0                                  
 2022584:	9f c6 80 00 	call  %i2                                      
 2022588:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
 202258c:	10 80 00 0a 	b  20225b4 <Stack_check_Dump_threads_usage+0xfc>
 2022590:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
        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 );
 2022594:	05 00 81 86 	sethi  %hi(0x2061800), %g2                     
 2022598:	c2 00 60 a8 	ld  [ %g1 + 0xa8 ], %g1                        
 202259c:	d0 00 a0 a4 	ld  [ %g2 + 0xa4 ], %o0                        
 20225a0:	13 00 81 62 	sethi  %hi(0x2058800), %o1                     
 20225a4:	94 10 3f ff 	mov  -1, %o2                                   
 20225a8:	9f c0 40 00 	call  %g1                                      
 20225ac:	92 12 60 00 	mov  %o1, %o1                                  
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
 20225b0:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
 20225b4:	35 00 81 86 	sethi  %hi(0x2061800), %i2                     
 20225b8:	37 00 81 86 	sethi  %hi(0x2061800), %i3                     
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
 20225bc:	d6 07 40 00 	ld  [ %i5 ], %o3                               
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
 20225c0:	c2 06 a0 a8 	ld  [ %i2 + 0xa8 ], %g1                        
 20225c4:	d0 06 e0 a4 	ld  [ %i3 + 0xa4 ], %o0                        
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
 20225c8:	96 02 ff ff 	add  %o3, -1, %o3                              
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
 20225cc:	13 00 81 62 	sethi  %hi(0x2058800), %o1                     
 20225d0:	96 02 80 0b 	add  %o2, %o3, %o3                             
 20225d4:	92 12 60 10 	or  %o1, 0x10, %o1                             
 20225d8:	98 10 00 10 	mov  %l0, %o4                                  
 20225dc:	9f c0 40 00 	call  %g1                                      
 20225e0:	9a 10 00 19 	mov  %i1, %o5                                  
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
 20225e4:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 20225e8:	c2 00 60 a0 	ld  [ %g1 + 0xa0 ], %g1	! 20618a0 <Stack_check_Initialized>
    (*print_handler)( print_context, "Unavailable\n" );               
 20225ec:	d0 06 e0 a4 	ld  [ %i3 + 0xa4 ], %o0                        
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
 20225f0:	80 a0 60 00 	cmp  %g1, 0                                    
 20225f4:	12 80 00 07 	bne  2022610 <Stack_check_Dump_threads_usage+0x158><== ALWAYS TAKEN
 20225f8:	c2 06 a0 a8 	ld  [ %i2 + 0xa8 ], %g1                        
    (*print_handler)( print_context, "Unavailable\n" );               
 20225fc:	13 00 81 62 	sethi  %hi(0x2058800), %o1                     <== NOT EXECUTED
 2022600:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2022604:	92 12 60 30 	or  %o1, 0x30, %o1	! 2058830 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
 2022608:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 202260c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  } else {                                                            
    (*print_handler)( print_context, "%8" PRId32 "\n", used );        
 2022610:	13 00 81 62 	sethi  %hi(0x2058800), %o1                     
 2022614:	94 10 00 1c 	mov  %i4, %o2                                  
 2022618:	9f c0 40 00 	call  %g1                                      
 202261c:	92 12 60 40 	or  %o1, 0x40, %o1                             
 2022620:	81 c7 e0 08 	ret                                            
 2022624:	81 e8 00 00 	restore                                        
                                                                      

02022710 <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) {
 2022710:	9d e3 bf 80 	save  %sp, -128, %sp                           
  Stack_Control *stack = &running->Start.Initial_stack;               
  void          *pattern_area = Stack_check_Get_pattern(stack);       
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
 2022714:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
) 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);       
 2022718:	fa 06 20 b8 	ld  [ %i0 + 0xb8 ], %i5                        
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
 202271c:	7f ff 86 96 	call  2004174 <printk>                         
 2022720:	90 12 20 48 	or  %o0, 0x48, %o0                             
  printk("task control block: 0x%08" PRIxPTR "\n", running);          
 2022724:	92 10 00 18 	mov  %i0, %o1                                  
 2022728:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
 202272c:	7f ff 86 92 	call  2004174 <printk>                         
 2022730:	90 12 20 58 	or  %o0, 0x58, %o0	! 2058858 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328>
  printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);   
 2022734:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
 2022738:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
 202273c:	7f ff 86 8e 	call  2004174 <printk>                         
 2022740:	90 12 20 78 	or  %o0, 0x78, %o0	! 2058878 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348>
  printk(                                                             
 2022744:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         
 2022748:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
 202274c:	7f ff 86 8a 	call  2004174 <printk>                         
 2022750:	90 12 20 90 	or  %o0, 0x90, %o0	! 2058890 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360>
    "task name: 0x%08" PRIx32 "\n",                                   
    running->Object.name.name_u32                                     
  );                                                                  
  printk(                                                             
 2022754:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
 2022758:	94 07 bf e0 	add  %fp, -32, %o2                             
 202275c:	7f ff b1 cd 	call  200ee90 <rtems_object_get_name>          
 2022760:	92 10 20 20 	mov  0x20, %o1                                 
 2022764:	92 10 00 08 	mov  %o0, %o1                                  
 2022768:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
 202276c:	7f ff 86 82 	call  2004174 <printk>                         
 2022770:	90 12 20 a8 	or  %o0, 0xa8, %o0	! 20588a8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x378>
  );                                                                  
  printk(                                                             
    "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
 2022774:	d4 06 20 b8 	ld  [ %i0 + 0xb8 ], %o2                        
 2022778:	d2 06 20 b4 	ld  [ %i0 + 0xb4 ], %o1                        
  );                                                                  
  printk(                                                             
    "task name string: %s\n",                                         
    rtems_object_get_name(running->Object.id, sizeof(name), name)     
  );                                                                  
  printk(                                                             
 202277c:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
 2022780:	96 02 80 09 	add  %o2, %o1, %o3                             
 2022784:	7f ff 86 7c 	call  2004174 <printk>                         
 2022788:	90 12 20 c0 	or  %o0, 0xc0, %o0                             
    "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) {                                                  
 202278c:	80 a6 60 00 	cmp  %i1, 0                                    
 2022790:	32 80 00 09 	bne,a   20227b4 <Stack_check_report_blown_task+0xa4><== NEVER TAKEN
 2022794:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
    printk(                                                           
 2022798:	11 00 81 62 	sethi  %hi(0x2058800), %o0                     
 202279c:	92 10 20 10 	mov  0x10, %o1                                 
 20227a0:	90 12 20 f0 	or  %o0, 0xf0, %o0                             
 20227a4:	94 07 60 08 	add  %i5, 8, %o2                               
 20227a8:	7f ff 86 73 	call  2004174 <printk>                         
 20227ac:	96 07 60 18 	add  %i5, 0x18, %o3                            
          rtems_configuration_get_user_multiprocessing_table()->node  
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  rtems_fatal(                                                        
 20227b0:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         
 20227b4:	7f ff 94 e6 	call  2007b4c <rtems_fatal>                    
 20227b8:	90 10 20 09 	mov  9, %o0                                    
                                                                      

0200a790 <_CORE_RWLock_Release>: #include <rtems/score/watchdog.h> CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) {
 200a790:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  Thread_Control *executing = _Thread_Executing;                      
 200a794:	03 00 80 83 	sethi  %hi(0x2020c00), %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 );                                              
 200a798:	7f ff e4 d2 	call  2003ae0 <sparc_disable_interrupts>       
 200a79c:	fa 00 60 10 	ld  [ %g1 + 0x10 ], %i5	! 2020c10 <_Per_CPU_Information+0x10>
 200a7a0:	84 10 00 08 	mov  %o0, %g2                                  
    if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){          
 200a7a4:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
 200a7a8:	80 a0 60 00 	cmp  %g1, 0                                    
 200a7ac:	12 80 00 08 	bne  200a7cc <_CORE_RWLock_Release+0x3c>       
 200a7b0:	80 a0 60 01 	cmp  %g1, 1                                    
      _ISR_Enable( level );                                           
 200a7b4:	7f ff e4 cf 	call  2003af0 <sparc_enable_interrupts>        
 200a7b8:	b0 10 20 00 	clr  %i0                                       
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
 200a7bc:	82 10 20 02 	mov  2, %g1                                    
 200a7c0:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
 200a7c4:	81 c7 e0 08 	ret                                            
 200a7c8:	81 e8 00 00 	restore                                        
      return CORE_RWLOCK_SUCCESSFUL;                                  
    }                                                                 
    if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
 200a7cc:	32 80 00 0b 	bne,a   200a7f8 <_CORE_RWLock_Release+0x68>    
 200a7d0:	c0 27 60 34 	clr  [ %i5 + 0x34 ]                            
	the_rwlock->number_of_readers -= 1;                                  
 200a7d4:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
 200a7d8:	82 00 7f ff 	add  %g1, -1, %g1                              
	if ( the_rwlock->number_of_readers != 0 ) {                          
 200a7dc:	80 a0 60 00 	cmp  %g1, 0                                    
 200a7e0:	02 80 00 05 	be  200a7f4 <_CORE_RWLock_Release+0x64>        
 200a7e4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
          /* must be unlocked again */                                
	  _ISR_Enable( level );                                              
 200a7e8:	7f ff e4 c2 	call  2003af0 <sparc_enable_interrupts>        
 200a7ec:	b0 10 20 00 	clr  %i0                                       
          return CORE_RWLOCK_SUCCESSFUL;                              
 200a7f0:	30 80 00 24 	b,a   200a880 <_CORE_RWLock_Release+0xf0>      
        }                                                             
    }                                                                 
                                                                      
    /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */      
    executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;             
 200a7f4:	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;                 
 200a7f8:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            
  _ISR_Enable( level );                                               
 200a7fc:	7f ff e4 bd 	call  2003af0 <sparc_enable_interrupts>        
 200a800:	90 10 00 02 	mov  %g2, %o0                                  
                                                                      
  next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );            
 200a804:	40 00 07 b3 	call  200c6d0 <_Thread_queue_Dequeue>          
 200a808:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if ( next ) {                                                       
 200a80c:	80 a2 20 00 	cmp  %o0, 0                                    
 200a810:	22 80 00 1c 	be,a   200a880 <_CORE_RWLock_Release+0xf0>     
 200a814:	b0 10 20 00 	clr  %i0                                       
    if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
 200a818:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1                        
 200a81c:	80 a0 60 01 	cmp  %g1, 1                                    
 200a820:	32 80 00 05 	bne,a   200a834 <_CORE_RWLock_Release+0xa4>    
 200a824:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
      the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;     
 200a828:	82 10 20 02 	mov  2, %g1                                    
      return CORE_RWLOCK_SUCCESSFUL;                                  
 200a82c:	10 80 00 14 	b  200a87c <_CORE_RWLock_Release+0xec>         
 200a830:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        
    }                                                                 
                                                                      
    /*                                                                
     * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING                 
     */                                                               
    the_rwlock->number_of_readers += 1;                               
 200a834:	82 00 60 01 	inc  %g1                                       
 200a838:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
    the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;       
 200a83c:	82 10 20 01 	mov  1, %g1                                    
 200a840:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        
                                                                      
    /*                                                                
     * Now see if more readers can be let go.                         
     */                                                               
    while ( 1 ) {                                                     
      next = _Thread_queue_First( &the_rwlock->Wait_queue );          
 200a844:	40 00 08 df 	call  200cbc0 <_Thread_queue_First>            
 200a848:	90 10 00 18 	mov  %i0, %o0                                  
      if ( !next ||                                                   
 200a84c:	92 92 20 00 	orcc  %o0, 0, %o1                              
 200a850:	22 80 00 0c 	be,a   200a880 <_CORE_RWLock_Release+0xf0>     
 200a854:	b0 10 20 00 	clr  %i0                                       
 200a858:	c2 02 60 30 	ld  [ %o1 + 0x30 ], %g1                        
 200a85c:	80 a0 60 01 	cmp  %g1, 1                                    
 200a860:	02 80 00 07 	be  200a87c <_CORE_RWLock_Release+0xec>        <== NEVER TAKEN
 200a864:	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;                             
 200a868:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
 200a86c:	82 00 60 01 	inc  %g1                                       
      _Thread_queue_Extract( &the_rwlock->Wait_queue, next );         
 200a870:	40 00 08 85 	call  200ca84 <_Thread_queue_Extract>          
 200a874:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
    }                                                                 
 200a878:	30 bf ff f3 	b,a   200a844 <_CORE_RWLock_Release+0xb4>      
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
 200a87c:	b0 10 20 00 	clr  %i0                                       
 200a880:	81 c7 e0 08 	ret                                            
 200a884:	81 e8 00 00 	restore                                        
                                                                      

0200a888 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) {
 200a888:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 200a88c:	90 10 00 18 	mov  %i0, %o0                                  
 200a890:	40 00 06 b5 	call  200c364 <_Thread_Get>                    
 200a894:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 200a898:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200a89c:	80 a0 60 00 	cmp  %g1, 0                                    
 200a8a0:	12 80 00 08 	bne  200a8c0 <_CORE_RWLock_Timeout+0x38>       <== NEVER TAKEN
 200a8a4:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
 200a8a8:	40 00 09 03 	call  200ccb4 <_Thread_queue_Process_timeout>  
 200a8ac:	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;                  
 200a8b0:	03 00 80 81 	sethi  %hi(0x2020400), %g1                     
 200a8b4:	c4 00 62 e0 	ld  [ %g1 + 0x2e0 ], %g2	! 20206e0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
 200a8b8:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
 200a8bc:	c4 20 62 e0 	st  %g2, [ %g1 + 0x2e0 ]                       
 200a8c0:	81 c7 e0 08 	ret                                            
 200a8c4:	81 e8 00 00 	restore                                        
                                                                      

020085d8 <_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 ) {
 20085d8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
 20085dc:	90 10 00 18 	mov  %i0, %o0                                  
 20085e0:	40 00 07 83 	call  200a3ec <_Thread_queue_Dequeue>          
 20085e4:	ba 10 00 18 	mov  %i0, %i5                                  
 20085e8:	80 a2 20 00 	cmp  %o0, 0                                    
 20085ec:	12 80 00 0e 	bne  2008624 <_CORE_semaphore_Surrender+0x4c>  
 20085f0:	b0 10 20 00 	clr  %i0                                       
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )             
      (*api_semaphore_mp_support) ( the_thread, id );                 
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
 20085f4:	7f ff e7 f4 	call  20025c4 <sparc_disable_interrupts>       
 20085f8:	01 00 00 00 	nop                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
 20085fc:	c2 07 60 48 	ld  [ %i5 + 0x48 ], %g1                        
 2008600:	c4 07 60 40 	ld  [ %i5 + 0x40 ], %g2                        
 2008604:	80 a0 40 02 	cmp  %g1, %g2                                  
 2008608:	1a 80 00 05 	bcc  200861c <_CORE_semaphore_Surrender+0x44>  <== NEVER TAKEN
 200860c:	b0 10 20 04 	mov  4, %i0                                    
        the_semaphore->count += 1;                                    
 2008610:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
 2008614:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;                                    
 2008618:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
 200861c:	7f ff e7 ee 	call  20025d4 <sparc_enable_interrupts>        
 2008620:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
 2008624:	81 c7 e0 08 	ret                                            
 2008628:	81 e8 00 00 	restore                                        
                                                                      

02007260 <_Event_Surrender>: rtems_event_set event_in, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) {
 2007260:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_event_set pending_events;                                     
  rtems_event_set event_condition;                                    
  rtems_event_set seized_events;                                      
  rtems_option    option_set;                                         
                                                                      
  option_set = the_thread->Wait.option;                               
 2007264:	e0 06 20 30 	ld  [ %i0 + 0x30 ], %l0                        
                                                                      
  _ISR_Disable( level );                                              
 2007268:	7f ff ec d7 	call  20025c4 <sparc_disable_interrupts>       
 200726c:	ba 10 00 18 	mov  %i0, %i5                                  
 2007270:	b0 10 00 08 	mov  %o0, %i0                                  
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;                                   
 2007274:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 2007278:	b2 16 40 01 	or  %i1, %g1, %i1                              
 200727c:	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;                           
 2007280:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
  seized_events = _Event_sets_Get( pending_events, event_condition ); 
                                                                      
  /*                                                                  
   *  No events were seized in this operation                         
   */                                                                 
  if ( _Event_sets_Is_empty( seized_events ) ) {                      
 2007284:	82 8e 40 02 	andcc  %i1, %g2, %g1                           
 2007288:	02 80 00 3d 	be  200737c <_Event_Surrender+0x11c>           
 200728c:	07 00 80 76 	sethi  %hi(0x201d800), %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() &&                                       
 2007290:	86 10 e2 f0 	or  %g3, 0x2f0, %g3	! 201daf0 <_Per_CPU_Information>
 2007294:	c8 00 e0 08 	ld  [ %g3 + 8 ], %g4                           
 2007298:	80 a1 20 00 	cmp  %g4, 0                                    
 200729c:	22 80 00 18 	be,a   20072fc <_Event_Surrender+0x9c>         
 20072a0:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
 20072a4:	c6 00 e0 10 	ld  [ %g3 + 0x10 ], %g3                        
 20072a8:	80 a7 40 03 	cmp  %i5, %g3                                  
 20072ac:	32 80 00 14 	bne,a   20072fc <_Event_Surrender+0x9c>        
 20072b0:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
       _Thread_Is_executing( the_thread ) &&                          
       ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||         
 20072b4:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
 20072b8:	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 ) &&                          
 20072bc:	80 a0 e0 01 	cmp  %g3, 1                                    
 20072c0:	38 80 00 0f 	bgu,a   20072fc <_Event_Surrender+0x9c>        
 20072c4:	c6 07 60 10 	ld  [ %i5 + 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) ) {
 20072c8:	80 a0 40 02 	cmp  %g1, %g2                                  
 20072cc:	02 80 00 04 	be  20072dc <_Event_Surrender+0x7c>            
 20072d0:	80 8c 20 02 	btst  2, %l0                                   
 20072d4:	02 80 00 2a 	be  200737c <_Event_Surrender+0x11c>           <== NEVER TAKEN
 20072d8:	01 00 00 00 	nop                                            
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) );                            
 20072dc:	b2 2e 40 01 	andn  %i1, %g1, %i1                            
      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;
 20072e0:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
  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(                      
 20072e4:	f2 26 80 00 	st  %i1, [ %i2 ]                               
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
 20072e8:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
 20072ec:	c2 20 80 00 	st  %g1, [ %g2 ]                               
      *sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;              
 20072f0:	82 10 20 03 	mov  3, %g1                                    
 20072f4:	10 80 00 22 	b  200737c <_Event_Surrender+0x11c>            
 20072f8:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Otherwise, this is a normal send to another thread              
   */                                                                 
  if ( _States_Are_set( the_thread->current_state, wait_state ) ) {   
 20072fc:	80 8f 00 03 	btst  %i4, %g3                                 
 2007300:	02 80 00 1f 	be  200737c <_Event_Surrender+0x11c>           
 2007304:	80 a0 40 02 	cmp  %g1, %g2                                  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
 2007308:	02 80 00 04 	be  2007318 <_Event_Surrender+0xb8>            
 200730c:	80 8c 20 02 	btst  2, %l0                                   
 2007310:	02 80 00 1b 	be  200737c <_Event_Surrender+0x11c>           <== NEVER TAKEN
 2007314:	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;
 2007318:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
 200731c:	b2 2e 40 01 	andn  %i1, %g1, %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(                      
 2007320:	f2 26 80 00 	st  %i1, [ %i2 ]                               
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
 2007324:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
 2007328:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _ISR_Flash( level );                                            
 200732c:	7f ff ec aa 	call  20025d4 <sparc_enable_interrupts>        
 2007330:	90 10 00 18 	mov  %i0, %o0                                  
 2007334:	7f ff ec a4 	call  20025c4 <sparc_disable_interrupts>       
 2007338:	01 00 00 00 	nop                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
 200733c:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
 2007340:	80 a0 60 02 	cmp  %g1, 2                                    
 2007344:	02 80 00 06 	be  200735c <_Event_Surrender+0xfc>            
 2007348:	82 10 20 03 	mov  3, %g1                                    
        _ISR_Enable( level );                                         
 200734c:	7f ff ec a2 	call  20025d4 <sparc_enable_interrupts>        
 2007350:	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 );                  
 2007354:	10 80 00 08 	b  2007374 <_Event_Surrender+0x114>            
 2007358:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_END+0xdc7fff8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
 200735c:	c2 27 60 50 	st  %g1, [ %i5 + 0x50 ]                        
        _Thread_Unblock( the_thread );                                
      } else {                                                        
        _Watchdog_Deactivate( &the_thread->Timer );                   
        _ISR_Enable( level );                                         
 2007360:	7f ff ec 9d 	call  20025d4 <sparc_enable_interrupts>        
 2007364:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    
        (void) _Watchdog_Remove( &the_thread->Timer );                
 2007368:	40 00 0e b7 	call  200ae44 <_Watchdog_Remove>               
 200736c:	90 07 60 48 	add  %i5, 0x48, %o0                            
 2007370:	b2 16 63 f8 	or  %i1, 0x3f8, %i1                            
 2007374:	40 00 0a 49 	call  2009c98 <_Thread_Clear_state>            
 2007378:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
 200737c:	7f ff ec 96 	call  20025d4 <sparc_enable_interrupts>        
 2007380:	81 e8 00 00 	restore                                        
                                                                      

02007384 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *arg ) {
 2007384:	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 );                          
 2007388:	90 10 00 18 	mov  %i0, %o0                                  
 200738c:	40 00 0b 3d 	call  200a080 <_Thread_Get>                    
 2007390:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 2007394:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2007398:	80 a0 60 00 	cmp  %g1, 0                                    
 200739c:	12 80 00 1b 	bne  2007408 <_Event_Timeout+0x84>             <== NEVER TAKEN
 20073a0:	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 );                                          
 20073a4:	7f ff ec 88 	call  20025c4 <sparc_disable_interrupts>       
 20073a8:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
 20073ac:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
 20073b0:	c2 00 63 00 	ld  [ %g1 + 0x300 ], %g1	! 201db00 <_Per_CPU_Information+0x10>
 20073b4:	80 a7 40 01 	cmp  %i5, %g1                                  
 20073b8:	12 80 00 08 	bne  20073d8 <_Event_Timeout+0x54>             
 20073bc:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
          if ( *sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
 20073c0:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 20073c4:	80 a0 60 01 	cmp  %g1, 1                                    
 20073c8:	12 80 00 05 	bne  20073dc <_Event_Timeout+0x58>             
 20073cc:	82 10 20 06 	mov  6, %g1                                    
            *sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;          
 20073d0:	82 10 20 02 	mov  2, %g1                                    
 20073d4:	c2 26 40 00 	st  %g1, [ %i1 ]                               
        }                                                             
                                                                      
        the_thread->Wait.return_code = RTEMS_TIMEOUT;                 
 20073d8:	82 10 20 06 	mov  6, %g1                                    
 20073dc:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
      _ISR_Enable( level );                                           
 20073e0:	7f ff ec 7d 	call  20025d4 <sparc_enable_interrupts>        
 20073e4:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
 20073e8:	90 10 00 1d 	mov  %i5, %o0                                  
 20073ec:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
 20073f0:	40 00 0a 2a 	call  2009c98 <_Thread_Clear_state>            
 20073f4:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1007fff8 <RAM_END+0xdc7fff8>
   *                                                                  
   * 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;                  
 20073f8:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20073fc:	c4 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g2	! 201d5d0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
 2007400:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
 2007404:	c4 20 61 d0 	st  %g2, [ %g1 + 0x1d0 ]                       
 2007408:	81 c7 e0 08 	ret                                            
 200740c:	81 e8 00 00 	restore                                        
                                                                      

0200d550 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) {
 200d550:	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 ) {                                    
 200d554:	80 a6 60 00 	cmp  %i1, 0                                    
 200d558:	02 80 00 7a 	be  200d740 <_Heap_Free+0x1f0>                 
 200d55c:	88 10 20 01 	mov  1, %g4                                    
 200d560:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
 200d564:	40 00 2c 8d 	call  2018798 <.urem>                          
 200d568:	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           
 200d56c:	f6 06 20 20 	ld  [ %i0 + 0x20 ], %i3                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
 200d570:	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);                                        
 200d574:	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;             
 200d578:	80 a2 00 1b 	cmp  %o0, %i3                                  
 200d57c:	0a 80 00 05 	bcs  200d590 <_Heap_Free+0x40>                 
 200d580:	82 10 20 00 	clr  %g1                                       
 200d584:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 200d588:	80 a0 40 08 	cmp  %g1, %o0                                  
 200d58c:	82 60 3f ff 	subx  %g0, -1, %g1                             
  }                                                                   
                                                                      
  alloc_begin = (uintptr_t) alloc_begin_ptr;                          
  block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );  
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, block ) ) {                     
 200d590:	80 a0 60 00 	cmp  %g1, 0                                    
 200d594:	02 80 00 6b 	be  200d740 <_Heap_Free+0x1f0>                 
 200d598:	88 10 20 00 	clr  %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;                
 200d59c:	f8 02 20 04 	ld  [ %o0 + 4 ], %i4                           
 200d5a0:	84 0f 3f fe 	and  %i4, -2, %g2                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200d5a4:	82 02 00 02 	add  %o0, %g2, %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;             
 200d5a8:	80 a0 40 1b 	cmp  %g1, %i3                                  
 200d5ac:	0a 80 00 05 	bcs  200d5c0 <_Heap_Free+0x70>                 <== NEVER TAKEN
 200d5b0:	86 10 20 00 	clr  %g3                                       
 200d5b4:	c6 06 20 24 	ld  [ %i0 + 0x24 ], %g3                        
 200d5b8:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200d5bc:	86 60 3f ff 	subx  %g0, -1, %g3                             
  _Heap_Protection_block_check( heap, block );                        
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {                
 200d5c0:	80 a0 e0 00 	cmp  %g3, 0                                    
 200d5c4:	02 80 00 5f 	be  200d740 <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200d5c8:	88 10 20 00 	clr  %g4                                       
  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;                 
 200d5cc:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
    return false;                                                     
  }                                                                   
                                                                      
  _Heap_Protection_block_check( heap, next_block );                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
 200d5d0:	80 8f 60 01 	btst  1, %i5                                   
 200d5d4:	22 80 00 5c 	be,a   200d744 <_Heap_Free+0x1f4>              <== NEVER TAKEN
 200d5d8:	b0 09 20 01 	and  %g4, 1, %i0                               <== NOT EXECUTED
  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                       
 200d5dc:	c8 06 20 24 	ld  [ %i0 + 0x24 ], %g4                        
    && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
 200d5e0:	80 a0 40 04 	cmp  %g1, %g4                                  
 200d5e4:	02 80 00 07 	be  200d600 <_Heap_Free+0xb0>                  
 200d5e8:	ba 0f 7f fe 	and  %i5, -2, %i5                              
 200d5ec:	86 00 40 1d 	add  %g1, %i5, %g3                             
 200d5f0:	f4 00 e0 04 	ld  [ %g3 + 4 ], %i2                           
 200d5f4:	b4 1e a0 01 	xor  %i2, 1, %i2                               
 200d5f8:	10 80 00 03 	b  200d604 <_Heap_Free+0xb4>                   
 200d5fc:	b4 0e a0 01 	and  %i2, 1, %i2                               
 200d600:	b4 10 20 00 	clr  %i2                                       
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
 200d604:	80 8f 20 01 	btst  1, %i4                                   
 200d608:	12 80 00 26 	bne  200d6a0 <_Heap_Free+0x150>                
 200d60c:	80 8e a0 ff 	btst  0xff, %i2                                
    uintptr_t const prev_size = block->prev_size;                     
 200d610:	f8 02 00 00 	ld  [ %o0 ], %i4                               
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200d614:	86 22 00 1c 	sub  %o0, %i4, %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;             
 200d618:	80 a0 c0 1b 	cmp  %g3, %i3                                  
 200d61c:	0a 80 00 04 	bcs  200d62c <_Heap_Free+0xdc>                 <== NEVER TAKEN
 200d620:	b2 10 20 00 	clr  %i1                                       
 200d624:	80 a1 00 03 	cmp  %g4, %g3                                  
 200d628:	b2 60 3f ff 	subx  %g0, -1, %i1                             
    Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
                                                                      
    if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {              
 200d62c:	80 a6 60 00 	cmp  %i1, 0                                    
 200d630:	02 80 00 44 	be  200d740 <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200d634:	88 10 20 00 	clr  %g4                                       
  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;                 
 200d638:	f6 00 e0 04 	ld  [ %g3 + 4 ], %i3                           
      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) ) {                        
 200d63c:	80 8e e0 01 	btst  1, %i3                                   
 200d640:	02 80 00 40 	be  200d740 <_Heap_Free+0x1f0>                 <== NEVER TAKEN
 200d644:	80 8e a0 ff 	btst  0xff, %i2                                
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
 200d648:	22 80 00 0f 	be,a   200d684 <_Heap_Free+0x134>              
 200d64c:	b8 00 80 1c 	add  %g2, %i4, %i4                             
  return _Heap_Free_list_tail(heap)->prev;                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) 
{                                                                     
  Heap_Block *next = block->next;                                     
 200d650:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
  Heap_Block *prev = block->prev;                                     
 200d654:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
      uintptr_t const size = block_size + prev_size + next_block_size;
 200d658:	ba 00 80 1d 	add  %g2, %i5, %i5                             
                                                                      
  prev->next = next;                                                  
 200d65c:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
  next->prev = prev;                                                  
 200d660:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
 200d664:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
      uintptr_t const size = block_size + prev_size + next_block_size;
 200d668:	b8 07 40 1c 	add  %i5, %i4, %i4                             
      _Heap_Free_list_remove( next_block );                           
      stats->free_blocks -= 1;                                        
 200d66c:	82 00 7f ff 	add  %g1, -1, %g1                              
 200d670:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
      prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;        
      next_block = _Heap_Block_at( prev_block, size );                
      _HAssert(!_Heap_Is_prev_used( next_block));                     
      next_block->prev_size = size;                                   
 200d674:	f8 20 c0 1c 	st  %i4, [ %g3 + %i4 ]                         
                                                                      
    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;        
 200d678:	82 17 20 01 	or  %i4, 1, %g1                                
 200d67c:	10 80 00 27 	b  200d718 <_Heap_Free+0x1c8>                  
 200d680:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
      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;        
 200d684:	88 17 20 01 	or  %i4, 1, %g4                                
 200d688:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
 200d68c:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
      next_block->prev_size = size;                                   
 200d690:	f8 22 00 02 	st  %i4, [ %o0 + %g2 ]                         
      _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;             
 200d694:	86 08 ff fe 	and  %g3, -2, %g3                              
 200d698:	10 80 00 20 	b  200d718 <_Heap_Free+0x1c8>                  
 200d69c:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
      next_block->prev_size = size;                                   
    }                                                                 
  } else if ( next_is_free ) {    /* coalesce next */                 
 200d6a0:	22 80 00 0d 	be,a   200d6d4 <_Heap_Free+0x184>              
 200d6a4:	c6 06 20 08 	ld  [ %i0 + 8 ], %g3                           
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(                    
  Heap_Block *old_block,                                              
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = old_block->next;                                 
 200d6a8:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
  Heap_Block *prev = old_block->prev;                                 
 200d6ac:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
                                                                      
  new_block->next = next;                                             
 200d6b0:	c8 22 20 08 	st  %g4, [ %o0 + 8 ]                           
  new_block->prev = prev;                                             
 200d6b4:	c2 22 20 0c 	st  %g1, [ %o0 + 0xc ]                         
    uintptr_t const size = block_size + next_block_size;              
 200d6b8:	86 07 40 02 	add  %i5, %g2, %g3                             
                                                                      
  next->prev = new_block;                                             
  prev->next = new_block;                                             
 200d6bc:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
  Heap_Block *prev = old_block->prev;                                 
                                                                      
  new_block->next = next;                                             
  new_block->prev = prev;                                             
                                                                      
  next->prev = new_block;                                             
 200d6c0:	d0 21 20 0c 	st  %o0, [ %g4 + 0xc ]                         
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
 200d6c4:	82 10 e0 01 	or  %g3, 1, %g1                                
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
 200d6c8:	c6 22 00 03 	st  %g3, [ %o0 + %g3 ]                         
      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;               
 200d6cc:	10 80 00 13 	b  200d718 <_Heap_Free+0x1c8>                  
 200d6d0:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
 200d6d4:	f0 22 20 0c 	st  %i0, [ %o0 + 0xc ]                         
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
 200d6d8:	c6 22 20 08 	st  %g3, [ %o0 + 8 ]                           
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
 200d6dc:	d0 20 e0 0c 	st  %o0, [ %g3 + 0xc ]                         
    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;         
 200d6e0:	86 10 a0 01 	or  %g2, 1, %g3                                
 200d6e4:	c6 22 20 04 	st  %g3, [ %o0 + 4 ]                           
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
 200d6e8:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
    next_block->prev_size = block_size;                               
 200d6ec:	c4 22 00 02 	st  %g2, [ %o0 + %g2 ]                         
  } 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;               
 200d6f0:	86 08 ff fe 	and  %g3, -2, %g3                              
 200d6f4:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
 200d6f8:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
    if ( stats->max_free_blocks < stats->free_blocks ) {              
 200d6fc:	c6 06 20 3c 	ld  [ %i0 + 0x3c ], %g3                        
    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;                                             
 200d700:	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;                                     
 200d704:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
    if ( stats->max_free_blocks < stats->free_blocks ) {              
 200d708:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200d70c:	1a 80 00 03 	bcc  200d718 <_Heap_Free+0x1c8>                
 200d710:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
 200d714:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
 200d718:	c2 06 20 40 	ld  [ %i0 + 0x40 ], %g1                        
 200d71c:	82 00 7f ff 	add  %g1, -1, %g1                              
 200d720:	c2 26 20 40 	st  %g1, [ %i0 + 0x40 ]                        
  ++stats->frees;                                                     
 200d724:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
 200d728:	82 00 60 01 	inc  %g1                                       
 200d72c:	c2 26 20 50 	st  %g1, [ %i0 + 0x50 ]                        
  stats->free_size += block_size;                                     
 200d730:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
 200d734:	84 00 40 02 	add  %g1, %g2, %g2                             
 200d738:	c4 26 20 30 	st  %g2, [ %i0 + 0x30 ]                        
   * If NULL return true so a free on NULL is considered a valid release. This
   * is a special case that could be handled by the in heap check how-ever that
   * would result in false being returned which is wrong.             
   */                                                                 
  if ( alloc_begin_ptr == NULL ) {                                    
    return true;                                                      
 200d73c:	88 10 20 01 	mov  1, %g4                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
                                                                      
  return( true );                                                     
}                                                                     
 200d740:	b0 09 20 01 	and  %g4, 1, %i0                               
 200d744:	81 c7 e0 08 	ret                                            
 200d748:	81 e8 00 00 	restore                                        
                                                                      

0200a750 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) {
 200a750:	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) {                                 
 200a754:	b6 10 20 00 	clr  %i3                                       
Heap_Block *_Heap_Greedy_allocate(                                    
  Heap_Control *heap,                                                 
  const uintptr_t *block_sizes,                                       
  size_t block_count                                                  
)                                                                     
{                                                                     
 200a758:	ba 10 00 18 	mov  %i0, %i5                                  
  Heap_Block *allocated_blocks = NULL;                                
  Heap_Block *blocks = NULL;                                          
  Heap_Block *current;                                                
  size_t i;                                                           
                                                                      
  for (i = 0; i < block_count; ++i) {                                 
 200a75c:	10 80 00 11 	b  200a7a0 <_Heap_Greedy_allocate+0x50>        
 200a760:	b8 10 20 00 	clr  %i4                                       
 * @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 );    
 200a764:	d2 06 40 01 	ld  [ %i1 + %g1 ], %o1                         
 200a768:	90 10 00 1d 	mov  %i5, %o0                                  
 200a76c:	94 10 20 00 	clr  %o2                                       
 200a770:	40 00 1d 8e 	call  2011da8 <_Heap_Allocate_aligned_with_boundary>
 200a774:	96 10 20 00 	clr  %o3                                       
    void *next = _Heap_Allocate( heap, block_sizes [i] );             
                                                                      
    if ( next != NULL ) {                                             
 200a778:	82 92 20 00 	orcc  %o0, 0, %g1                              
 200a77c:	22 80 00 09 	be,a   200a7a0 <_Heap_Greedy_allocate+0x50>    <== NEVER TAKEN
 200a780:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
 200a784:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        
 200a788:	40 00 4a 8c 	call  201d1b8 <.urem>                          
 200a78c:	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);                                        
 200a790:	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;                            
 200a794:	f8 22 20 08 	st  %i4, [ %o0 + 8 ]                           
 200a798:	b8 10 00 08 	mov  %o0, %i4                                  
  Heap_Block *allocated_blocks = NULL;                                
  Heap_Block *blocks = NULL;                                          
  Heap_Block *current;                                                
  size_t i;                                                           
                                                                      
  for (i = 0; i < block_count; ++i) {                                 
 200a79c:	b6 06 e0 01 	inc  %i3                                       
 200a7a0:	80 a6 c0 1a 	cmp  %i3, %i2                                  
 200a7a4:	12 bf ff f0 	bne  200a764 <_Heap_Greedy_allocate+0x14>      
 200a7a8:	83 2e e0 02 	sll  %i3, 2, %g1                               
 200a7ac:	10 80 00 0a 	b  200a7d4 <_Heap_Greedy_allocate+0x84>        
 200a7b0:	b0 10 20 00 	clr  %i0                                       
      allocated_blocks = next_block;                                  
    }                                                                 
  }                                                                   
                                                                      
  while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
    _Heap_Block_allocate(                                             
 200a7b4:	90 10 00 1d 	mov  %i5, %o0                                  
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{                                                                     
  return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;                
 200a7b8:	96 0a ff fe 	and  %o3, -2, %o3                              
 200a7bc:	92 10 00 1b 	mov  %i3, %o1                                  
 200a7c0:	94 06 e0 08 	add  %i3, 8, %o2                               
 200a7c4:	40 00 00 cb 	call  200aaf0 <_Heap_Block_allocate>           
 200a7c8:	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;                                           
 200a7cc:	f0 26 e0 08 	st  %i0, [ %i3 + 8 ]                           
 200a7d0:	b0 10 00 1b 	mov  %i3, %i0                                  
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
 200a7d4:	f6 07 60 08 	ld  [ %i5 + 8 ], %i3                           
      next_block->next = allocated_blocks;                            
      allocated_blocks = next_block;                                  
    }                                                                 
  }                                                                   
                                                                      
  while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
 200a7d8:	80 a6 c0 1d 	cmp  %i3, %i5                                  
 200a7dc:	32 bf ff f6 	bne,a   200a7b4 <_Heap_Greedy_allocate+0x64>   
 200a7e0:	d6 06 e0 04 	ld  [ %i3 + 4 ], %o3                           
                                                                      
    current->next = blocks;                                           
    blocks = current;                                                 
  }                                                                   
                                                                      
  while ( allocated_blocks != NULL ) {                                
 200a7e4:	10 80 00 07 	b  200a800 <_Heap_Greedy_allocate+0xb0>        
 200a7e8:	80 a7 20 00 	cmp  %i4, 0                                    
    current = allocated_blocks;                                       
    allocated_blocks = allocated_blocks->next;                        
    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
 200a7ec:	92 07 20 08 	add  %i4, 8, %o1                               
 200a7f0:	90 10 00 1d 	mov  %i5, %o0                                  
 200a7f4:	40 00 1d de 	call  2011f6c <_Heap_Free>                     
 200a7f8:	b8 10 00 1b 	mov  %i3, %i4                                  
                                                                      
    current->next = blocks;                                           
    blocks = current;                                                 
  }                                                                   
                                                                      
  while ( allocated_blocks != NULL ) {                                
 200a7fc:	80 a7 20 00 	cmp  %i4, 0                                    
 200a800:	32 bf ff fb 	bne,a   200a7ec <_Heap_Greedy_allocate+0x9c>   
 200a804:	f6 07 20 08 	ld  [ %i4 + 8 ], %i3                           
    allocated_blocks = allocated_blocks->next;                        
    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
  }                                                                   
                                                                      
  return blocks;                                                      
}                                                                     
 200a808:	81 c7 e0 08 	ret                                            
 200a80c:	81 e8 00 00 	restore                                        
                                                                      

020120f0 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) {
 20120f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Block *current = heap->first_block;                            
  Heap_Block *end = heap->last_block;                                 
  bool stop = false;                                                  
 20120f4:	90 10 20 00 	clr  %o0                                       
  Heap_Control *heap,                                                 
  Heap_Block_visitor visitor,                                         
  void *visitor_arg                                                   
)                                                                     
{                                                                     
  Heap_Block *current = heap->first_block;                            
 20120f8:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
  Heap_Block *end = heap->last_block;                                 
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != end ) {                                 
 20120fc:	10 80 00 0a 	b  2012124 <_Heap_Iterate+0x34>                
 2012100:	f8 06 20 24 	ld  [ %i0 + 0x24 ], %i4                        
    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 );            
 2012104:	90 10 00 01 	mov  %g1, %o0                                  
 2012108:	92 0a 7f fe 	and  %o1, -2, %o1                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 201210c:	ba 00 40 09 	add  %g1, %o1, %i5                             
  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;                 
 2012110:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
 2012114:	96 10 00 1a 	mov  %i2, %o3                                  
 2012118:	9f c6 40 00 	call  %i1                                      
 201211c:	94 0a a0 01 	and  %o2, 1, %o2                               
 2012120:	82 10 00 1d 	mov  %i5, %g1                                  
{                                                                     
  Heap_Block *current = heap->first_block;                            
  Heap_Block *end = heap->last_block;                                 
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != end ) {                                 
 2012124:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2012128:	02 80 00 05 	be  201213c <_Heap_Iterate+0x4c>               
 201212c:	90 1a 20 01 	xor  %o0, 1, %o0                               
 2012130:	80 8a 20 ff 	btst  0xff, %o0                                
 2012134:	32 bf ff f4 	bne,a   2012104 <_Heap_Iterate+0x14>           <== ALWAYS TAKEN
 2012138:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           
 201213c:	81 c7 e0 08 	ret                                            
 2012140:	81 e8 00 00 	restore                                        
                                                                      

0200d874 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) {
 200d874:	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);                                 
 200d878:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
 200d87c:	40 00 2b c7 	call  2018798 <.urem>                          
 200d880:	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           
 200d884:	c8 06 20 20 	ld  [ %i0 + 0x20 ], %g4                        
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(                      
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return value - (value % alignment);                                 
 200d888:	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);                                        
 200d88c:	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;             
 200d890:	80 a2 00 04 	cmp  %o0, %g4                                  
 200d894:	0a 80 00 05 	bcs  200d8a8 <_Heap_Size_of_alloc_area+0x34>   
 200d898:	82 10 20 00 	clr  %g1                                       
 200d89c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 200d8a0:	80 a0 40 08 	cmp  %g1, %o0                                  
 200d8a4:	82 60 3f ff 	subx  %g0, -1, %g1                             
  uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;          
  Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
  Heap_Block *next_block = NULL;                                      
  uintptr_t block_size = 0;                                           
                                                                      
  if ( !_Heap_Is_block_in_heap( heap, block ) ) {                     
 200d8a8:	80 a0 60 00 	cmp  %g1, 0                                    
 200d8ac:	02 80 00 15 	be  200d900 <_Heap_Size_of_alloc_area+0x8c>    
 200d8b0:	86 10 20 00 	clr  %g3                                       
    - 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;                
 200d8b4:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
 200d8b8:	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);                 
 200d8bc:	82 02 00 01 	add  %o0, %g1, %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;             
 200d8c0:	80 a0 40 04 	cmp  %g1, %g4                                  
 200d8c4:	0a 80 00 05 	bcs  200d8d8 <_Heap_Size_of_alloc_area+0x64>   <== NEVER TAKEN
 200d8c8:	84 10 20 00 	clr  %g2                                       
 200d8cc:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
 200d8d0:	80 a0 80 01 	cmp  %g2, %g1                                  
 200d8d4:	84 60 3f ff 	subx  %g0, -1, %g2                             
  }                                                                   
                                                                      
  block_size = _Heap_Block_size( block );                             
  next_block = _Heap_Block_at( block, block_size );                   
                                                                      
  if (                                                                
 200d8d8:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d8dc:	02 80 00 09 	be  200d900 <_Heap_Size_of_alloc_area+0x8c>    <== NEVER TAKEN
 200d8e0:	86 10 20 00 	clr  %g3                                       
  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;                 
 200d8e4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    !_Heap_Is_block_in_heap( heap, next_block )                       
      || !_Heap_Is_prev_used( next_block )                            
 200d8e8:	80 88 a0 01 	btst  1, %g2                                   
 200d8ec:	02 80 00 05 	be  200d900 <_Heap_Size_of_alloc_area+0x8c>    <== NEVER TAKEN
 200d8f0:	82 20 40 19 	sub  %g1, %i1, %g1                             
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
                                                                      
  return true;                                                        
 200d8f4:	86 10 20 01 	mov  1, %g3                                    
      || !_Heap_Is_prev_used( next_block )                            
  ) {                                                                 
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
 200d8f8:	82 00 60 04 	add  %g1, 4, %g1                               
 200d8fc:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
  return true;                                                        
}                                                                     
 200d900:	b0 08 e0 01 	and  %g3, 1, %i0                               
 200d904:	81 c7 e0 08 	ret                                            
 200d908:	81 e8 00 00 	restore                                        
                                                                      

02009708 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) {
 2009708:	9d e3 bf 80 	save  %sp, -128, %sp                           
 200970c:	ac 10 00 19 	mov  %i1, %l6                                  
  uintptr_t const page_size = heap->page_size;                        
 2009710:	f8 06 20 10 	ld  [ %i0 + 0x10 ], %i4                        
  uintptr_t const min_block_size = heap->min_block_size;              
 2009714:	f6 06 20 14 	ld  [ %i0 + 0x14 ], %i3                        
  Heap_Block *const first_block = heap->first_block;                  
 2009718:	f2 06 20 20 	ld  [ %i0 + 0x20 ], %i1                        
  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;                      
 200971c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2009720:	02 80 00 05 	be  2009734 <_Heap_Walk+0x2c>                  
 2009724:	e0 06 20 24 	ld  [ %i0 + 0x24 ], %l0                        
 2009728:	3b 00 80 25 	sethi  %hi(0x2009400), %i5                     
 200972c:	10 80 00 04 	b  200973c <_Heap_Walk+0x34>                   
 2009730:	ba 17 62 b8 	or  %i5, 0x2b8, %i5	! 20096b8 <_Heap_Walk_print>
 2009734:	3b 00 80 25 	sethi  %hi(0x2009400), %i5                     
 2009738:	ba 17 62 b0 	or  %i5, 0x2b0, %i5	! 20096b0 <_Heap_Walk_print_nothing>
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
 200973c:	05 00 80 7f 	sethi  %hi(0x201fc00), %g2                     
 2009740:	c4 00 a2 e8 	ld  [ %g2 + 0x2e8 ], %g2	! 201fee8 <_System_state_Current>
 2009744:	80 a0 a0 03 	cmp  %g2, 3                                    
 2009748:	22 80 00 04 	be,a   2009758 <_Heap_Walk+0x50>               
 200974c:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
    return true;                                                      
 2009750:	10 80 01 2a 	b  2009bf8 <_Heap_Walk+0x4f0>                  
 2009754:	b0 10 20 01 	mov  1, %i0                                    
  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)(                                                         
 2009758:	da 06 20 18 	ld  [ %i0 + 0x18 ], %o5                        
 200975c:	c4 23 a0 5c 	st  %g2, [ %sp + 0x5c ]                        
 2009760:	f2 23 a0 60 	st  %i1, [ %sp + 0x60 ]                        
 2009764:	e0 23 a0 64 	st  %l0, [ %sp + 0x64 ]                        
 2009768:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
 200976c:	90 10 00 16 	mov  %l6, %o0                                  
 2009770:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
 2009774:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
 2009778:	92 10 20 00 	clr  %o1                                       
 200977c:	c4 23 a0 6c 	st  %g2, [ %sp + 0x6c ]                        
 2009780:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009784:	96 10 00 1c 	mov  %i4, %o3                                  
 2009788:	94 12 a1 30 	or  %o2, 0x130, %o2                            
 200978c:	9f c7 40 00 	call  %i5                                      
 2009790:	98 10 00 1b 	mov  %i3, %o4                                  
    heap->area_begin, heap->area_end,                                 
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
 2009794:	80 a7 20 00 	cmp  %i4, 0                                    
 2009798:	12 80 00 07 	bne  20097b4 <_Heap_Walk+0xac>                 
 200979c:	80 8f 20 07 	btst  7, %i4                                   
    (*printer)( source, true, "page size is zero\n" );                
 20097a0:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 20097a4:	90 10 00 16 	mov  %l6, %o0                                  
 20097a8:	92 10 20 01 	mov  1, %o1                                    
 20097ac:	10 80 00 37 	b  2009888 <_Heap_Walk+0x180>                  
 20097b0:	94 12 a1 c8 	or  %o2, 0x1c8, %o2                            
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
 20097b4:	22 80 00 08 	be,a   20097d4 <_Heap_Walk+0xcc>               
 20097b8:	90 10 00 1b 	mov  %i3, %o0                                  
    (*printer)(                                                       
 20097bc:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 20097c0:	90 10 00 16 	mov  %l6, %o0                                  
 20097c4:	92 10 20 01 	mov  1, %o1                                    
 20097c8:	94 12 a1 e0 	or  %o2, 0x1e0, %o2                            
 20097cc:	10 80 01 12 	b  2009c14 <_Heap_Walk+0x50c>                  
 20097d0:	96 10 00 1c 	mov  %i4, %o3                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
 20097d4:	7f ff e0 ec 	call  2001b84 <.urem>                          
 20097d8:	92 10 00 1c 	mov  %i4, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
 20097dc:	80 a2 20 00 	cmp  %o0, 0                                    
 20097e0:	22 80 00 08 	be,a   2009800 <_Heap_Walk+0xf8>               
 20097e4:	90 06 60 08 	add  %i1, 8, %o0                               
    (*printer)(                                                       
 20097e8:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 20097ec:	90 10 00 16 	mov  %l6, %o0                                  
 20097f0:	92 10 20 01 	mov  1, %o1                                    
 20097f4:	94 12 a2 00 	or  %o2, 0x200, %o2                            
 20097f8:	10 80 01 07 	b  2009c14 <_Heap_Walk+0x50c>                  
 20097fc:	96 10 00 1b 	mov  %i3, %o3                                  
 2009800:	7f ff e0 e1 	call  2001b84 <.urem>                          
 2009804:	92 10 00 1c 	mov  %i4, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
 2009808:	80 a2 20 00 	cmp  %o0, 0                                    
 200980c:	22 80 00 07 	be,a   2009828 <_Heap_Walk+0x120>              
 2009810:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
 2009814:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009818:	90 10 00 16 	mov  %l6, %o0                                  
 200981c:	92 10 20 01 	mov  1, %o1                                    
 2009820:	10 80 00 fc 	b  2009c10 <_Heap_Walk+0x508>                  
 2009824:	94 12 a2 28 	or  %o2, 0x228, %o2                            
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
 2009828:	80 88 a0 01 	btst  1, %g2                                   
 200982c:	32 80 00 07 	bne,a   2009848 <_Heap_Walk+0x140>             
 2009830:	f4 04 20 04 	ld  [ %l0 + 4 ], %i2                           
    (*printer)(                                                       
 2009834:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009838:	90 10 00 16 	mov  %l6, %o0                                  
 200983c:	92 10 20 01 	mov  1, %o1                                    
 2009840:	10 80 00 12 	b  2009888 <_Heap_Walk+0x180>                  
 2009844:	94 12 a2 60 	or  %o2, 0x260, %o2                            
    - 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;                
 2009848:	b4 0e bf fe 	and  %i2, -2, %i2                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200984c:	b4 04 00 1a 	add  %l0, %i2, %i2                             
  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;                 
 2009850:	c4 06 a0 04 	ld  [ %i2 + 4 ], %g2                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
 2009854:	80 88 a0 01 	btst  1, %g2                                   
 2009858:	12 80 00 07 	bne  2009874 <_Heap_Walk+0x16c>                
 200985c:	80 a6 80 19 	cmp  %i2, %i1                                  
    (*printer)(                                                       
 2009860:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009864:	90 10 00 16 	mov  %l6, %o0                                  
 2009868:	92 10 20 01 	mov  1, %o1                                    
 200986c:	10 80 00 07 	b  2009888 <_Heap_Walk+0x180>                  
 2009870:	94 12 a2 90 	or  %o2, 0x290, %o2                            
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
 2009874:	02 80 00 0a 	be  200989c <_Heap_Walk+0x194>                 
 2009878:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
 200987c:	90 10 00 16 	mov  %l6, %o0                                  
 2009880:	92 10 20 01 	mov  1, %o1                                    
 2009884:	94 12 a2 a8 	or  %o2, 0x2a8, %o2                            
 2009888:	9f c7 40 00 	call  %i5                                      
 200988c:	b0 10 20 00 	clr  %i0                                       
 2009890:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
 2009894:	81 c7 e0 08 	ret                                            
 2009898:	81 e8 00 00 	restore                                        
  int source,                                                         
  Heap_Walk_printer printer,                                          
  Heap_Control *heap                                                  
)                                                                     
{                                                                     
  uintptr_t const page_size = heap->page_size;                        
 200989c:	e2 06 20 10 	ld  [ %i0 + 0x10 ], %l1                        
  return &heap->free_list;                                            
}                                                                     
                                                                      
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{                                                                     
  return _Heap_Free_list_head(heap)->next;                            
 20098a0:	d6 06 20 08 	ld  [ %i0 + 8 ], %o3                           
  const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
 20098a4:	10 80 00 30 	b  2009964 <_Heap_Walk+0x25c>                  
 20098a8:	b2 10 00 18 	mov  %i0, %i1                                  
  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;             
 20098ac:	80 a0 c0 0b 	cmp  %g3, %o3                                  
 20098b0:	18 80 00 05 	bgu  20098c4 <_Heap_Walk+0x1bc>                
 20098b4:	84 10 20 00 	clr  %g2                                       
 20098b8:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
 20098bc:	80 a0 80 0b 	cmp  %g2, %o3                                  
 20098c0:	84 60 3f ff 	subx  %g0, -1, %g2                             
  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 ) {                            
    if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {              
 20098c4:	80 a0 a0 00 	cmp  %g2, 0                                    
 20098c8:	32 80 00 07 	bne,a   20098e4 <_Heap_Walk+0x1dc>             
 20098cc:	90 02 e0 08 	add  %o3, 8, %o0                               
      (*printer)(                                                     
 20098d0:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 20098d4:	90 10 00 16 	mov  %l6, %o0                                  
 20098d8:	92 10 20 01 	mov  1, %o1                                    
 20098dc:	10 80 00 ce 	b  2009c14 <_Heap_Walk+0x50c>                  
 20098e0:	94 12 a2 d8 	or  %o2, 0x2d8, %o2                            
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
 20098e4:	d6 27 bf fc 	st  %o3, [ %fp + -4 ]                          
 20098e8:	7f ff e0 a7 	call  2001b84 <.urem>                          
 20098ec:	92 10 00 11 	mov  %l1, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
 20098f0:	80 a2 20 00 	cmp  %o0, 0                                    
 20098f4:	02 80 00 07 	be  2009910 <_Heap_Walk+0x208>                 
 20098f8:	d6 07 bf fc 	ld  [ %fp + -4 ], %o3                          
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
 20098fc:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009900:	90 10 00 16 	mov  %l6, %o0                                  
 2009904:	92 10 20 01 	mov  1, %o1                                    
 2009908:	10 80 00 c3 	b  2009c14 <_Heap_Walk+0x50c>                  
 200990c:	94 12 a2 f8 	or  %o2, 0x2f8, %o2                            
    - 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;                
 2009910:	c4 02 e0 04 	ld  [ %o3 + 4 ], %g2                           
 2009914:	84 08 bf fe 	and  %g2, -2, %g2                              
  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;                 
 2009918:	84 02 c0 02 	add  %o3, %g2, %g2                             
 200991c:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
 2009920:	80 88 a0 01 	btst  1, %g2                                   
 2009924:	22 80 00 07 	be,a   2009940 <_Heap_Walk+0x238>              
 2009928:	d8 02 e0 0c 	ld  [ %o3 + 0xc ], %o4                         
      (*printer)(                                                     
 200992c:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009930:	90 10 00 16 	mov  %l6, %o0                                  
 2009934:	92 10 20 01 	mov  1, %o1                                    
 2009938:	10 80 00 b7 	b  2009c14 <_Heap_Walk+0x50c>                  
 200993c:	94 12 a3 28 	or  %o2, 0x328, %o2                            
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
 2009940:	80 a3 00 19 	cmp  %o4, %i1                                  
 2009944:	02 80 00 07 	be  2009960 <_Heap_Walk+0x258>                 
 2009948:	b2 10 00 0b 	mov  %o3, %i1                                  
      (*printer)(                                                     
 200994c:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009950:	90 10 00 16 	mov  %l6, %o0                                  
 2009954:	92 10 20 01 	mov  1, %o1                                    
 2009958:	10 80 00 4d 	b  2009a8c <_Heap_Walk+0x384>                  
 200995c:	94 12 a3 48 	or  %o2, 0x348, %o2                            
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    prev_block = free_block;                                          
    free_block = free_block->next;                                    
 2009960:	d6 02 e0 08 	ld  [ %o3 + 8 ], %o3                           
  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 ) {                            
 2009964:	80 a2 c0 18 	cmp  %o3, %i0                                  
 2009968:	32 bf ff d1 	bne,a   20098ac <_Heap_Walk+0x1a4>             
 200996c:	c6 06 20 20 	ld  [ %i0 + 0x20 ], %g3                        
  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)(                                                         
 2009970:	2b 00 80 72 	sethi  %hi(0x201c800), %l5                     
  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 ) {                            
 2009974:	b2 10 00 1a 	mov  %i2, %i1                                  
  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)(                                                         
 2009978:	aa 15 60 48 	or  %l5, 0x48, %l5                             
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
 200997c:	23 00 80 72 	sethi  %hi(0x201c800), %l1                     
 2009980:	2f 00 80 71 	sethi  %hi(0x201c400), %l7                     
    - 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;                
 2009984:	e4 06 60 04 	ld  [ %i1 + 4 ], %l2                           
  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;             
 2009988:	d8 06 20 20 	ld  [ %i0 + 0x20 ], %o4                        
    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;               
 200998c:	9e 1e 40 10 	xor  %i1, %l0, %o7                             
 2009990:	80 a0 00 0f 	cmp  %g0, %o7                                  
    - 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;                
 2009994:	a8 0c bf fe 	and  %l2, -2, %l4                              
 2009998:	9a 40 20 00 	addx  %g0, 0, %o5                              
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(                      
  const Heap_Block *block,                                            
  uintptr_t offset                                                    
)                                                                     
{                                                                     
  return (Heap_Block *) ((uintptr_t) block + offset);                 
 200999c:	a6 06 40 14 	add  %i1, %l4, %l3                             
  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;                 
 20099a0:	a4 0c a0 01 	and  %l2, 1, %l2                               
  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;             
 20099a4:	80 a3 00 13 	cmp  %o4, %l3                                  
 20099a8:	18 80 00 05 	bgu  20099bc <_Heap_Walk+0x2b4>                <== NEVER TAKEN
 20099ac:	9e 10 20 00 	clr  %o7                                       
 20099b0:	de 06 20 24 	ld  [ %i0 + 0x24 ], %o7                        
 20099b4:	80 a3 c0 13 	cmp  %o7, %l3                                  
 20099b8:	9e 60 3f ff 	subx  %g0, -1, %o7                             
                                                                      
    if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {              
 20099bc:	80 a3 e0 00 	cmp  %o7, 0                                    
 20099c0:	32 80 00 07 	bne,a   20099dc <_Heap_Walk+0x2d4>             
 20099c4:	da 27 bf f8 	st  %o5, [ %fp + -8 ]                          
      (*printer)(                                                     
 20099c8:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 20099cc:	90 10 00 16 	mov  %l6, %o0                                  
 20099d0:	92 10 20 01 	mov  1, %o1                                    
 20099d4:	10 80 00 2c 	b  2009a84 <_Heap_Walk+0x37c>                  
 20099d8:	94 12 a3 80 	or  %o2, 0x380, %o2                            
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
 20099dc:	90 10 00 14 	mov  %l4, %o0                                  
 20099e0:	7f ff e0 69 	call  2001b84 <.urem>                          
 20099e4:	92 10 00 1c 	mov  %i4, %o1                                  
 20099e8:	da 07 bf f8 	ld  [ %fp + -8 ], %o5                          
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
 20099ec:	80 a2 20 00 	cmp  %o0, 0                                    
 20099f0:	02 80 00 0c 	be  2009a20 <_Heap_Walk+0x318>                 
 20099f4:	9e 0b 60 ff 	and  %o5, 0xff, %o7                            
 20099f8:	80 a3 e0 00 	cmp  %o7, 0                                    
 20099fc:	02 80 00 19 	be  2009a60 <_Heap_Walk+0x358>                 
 2009a00:	80 a6 40 13 	cmp  %i1, %l3                                  
      (*printer)(                                                     
 2009a04:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009a08:	90 10 00 16 	mov  %l6, %o0                                  
 2009a0c:	92 10 20 01 	mov  1, %o1                                    
 2009a10:	94 12 a3 b0 	or  %o2, 0x3b0, %o2                            
 2009a14:	96 10 00 19 	mov  %i1, %o3                                  
 2009a18:	10 80 00 1d 	b  2009a8c <_Heap_Walk+0x384>                  
 2009a1c:	98 10 00 14 	mov  %l4, %o4                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
 2009a20:	80 a3 e0 00 	cmp  %o7, 0                                    
 2009a24:	02 80 00 0f 	be  2009a60 <_Heap_Walk+0x358>                 
 2009a28:	80 a6 40 13 	cmp  %i1, %l3                                  
 2009a2c:	80 a5 00 1b 	cmp  %l4, %i3                                  
 2009a30:	1a 80 00 0c 	bcc  2009a60 <_Heap_Walk+0x358>                
 2009a34:	80 a6 40 13 	cmp  %i1, %l3                                  
      (*printer)(                                                     
 2009a38:	90 10 00 16 	mov  %l6, %o0                                  
 2009a3c:	92 10 20 01 	mov  1, %o1                                    
 2009a40:	15 00 80 71 	sethi  %hi(0x201c400), %o2                     
 2009a44:	96 10 00 19 	mov  %i1, %o3                                  
 2009a48:	94 12 a3 e0 	or  %o2, 0x3e0, %o2                            
 2009a4c:	98 10 00 14 	mov  %l4, %o4                                  
 2009a50:	9f c7 40 00 	call  %i5                                      
 2009a54:	9a 10 00 1b 	mov  %i3, %o5                                  
        "block 0x%08x: next block 0x%08x is not a successor\n",       
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
 2009a58:	10 80 00 68 	b  2009bf8 <_Heap_Walk+0x4f0>                  
 2009a5c:	b0 10 20 00 	clr  %i0                                       
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
 2009a60:	2a 80 00 10 	bcs,a   2009aa0 <_Heap_Walk+0x398>             
 2009a64:	de 04 e0 04 	ld  [ %l3 + 4 ], %o7                           
 2009a68:	80 8b 60 ff 	btst  0xff, %o5                                
 2009a6c:	22 80 00 0d 	be,a   2009aa0 <_Heap_Walk+0x398>              
 2009a70:	de 04 e0 04 	ld  [ %l3 + 4 ], %o7                           
      (*printer)(                                                     
 2009a74:	15 00 80 72 	sethi  %hi(0x201c800), %o2                     
 2009a78:	90 10 00 16 	mov  %l6, %o0                                  
 2009a7c:	92 10 20 01 	mov  1, %o1                                    
 2009a80:	94 12 a0 10 	or  %o2, 0x10, %o2                             
 2009a84:	96 10 00 19 	mov  %i1, %o3                                  
 2009a88:	98 10 00 13 	mov  %l3, %o4                                  
 2009a8c:	9f c7 40 00 	call  %i5                                      
 2009a90:	b0 10 20 00 	clr  %i0                                       
 2009a94:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
 2009a98:	81 c7 e0 08 	ret                                            
 2009a9c:	81 e8 00 00 	restore                                        
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
 2009aa0:	80 8b e0 01 	btst  1, %o7                                   
 2009aa4:	12 80 00 3f 	bne  2009ba0 <_Heap_Walk+0x498>                
 2009aa8:	90 10 00 16 	mov  %l6, %o0                                  
    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 ?                                 
 2009aac:	da 06 60 0c 	ld  [ %i1 + 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)(                                                         
 2009ab0:	d8 06 20 08 	ld  [ %i0 + 8 ], %o4                           
 2009ab4:	80 a3 40 0c 	cmp  %o5, %o4                                  
 2009ab8:	02 80 00 08 	be  2009ad8 <_Heap_Walk+0x3d0>                 
 2009abc:	de 06 20 0c 	ld  [ %i0 + 0xc ], %o7                         
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
 2009ac0:	80 a3 40 18 	cmp  %o5, %i0                                  
 2009ac4:	12 80 00 07 	bne  2009ae0 <_Heap_Walk+0x3d8>                
 2009ac8:	96 14 60 b8 	or  %l1, 0xb8, %o3                             
 2009acc:	17 00 80 71 	sethi  %hi(0x201c400), %o3                     
 2009ad0:	10 80 00 04 	b  2009ae0 <_Heap_Walk+0x3d8>                  
 2009ad4:	96 12 e1 00 	or  %o3, 0x100, %o3	! 201c500 <__log2table+0x130>
  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)(                                                         
 2009ad8:	03 00 80 71 	sethi  %hi(0x201c400), %g1                     
 2009adc:	96 10 60 f0 	or  %g1, 0xf0, %o3	! 201c4f0 <__log2table+0x120>
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
 2009ae0:	d8 06 60 08 	ld  [ %i1 + 8 ], %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)(                                                         
 2009ae4:	80 a3 00 0f 	cmp  %o4, %o7                                  
 2009ae8:	02 80 00 06 	be  2009b00 <_Heap_Walk+0x3f8>                 
 2009aec:	80 a3 00 18 	cmp  %o4, %i0                                  
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
 2009af0:	12 80 00 06 	bne  2009b08 <_Heap_Walk+0x400>                
 2009af4:	9e 14 60 b8 	or  %l1, 0xb8, %o7                             
 2009af8:	10 80 00 04 	b  2009b08 <_Heap_Walk+0x400>                  
 2009afc:	9e 15 e1 20 	or  %l7, 0x120, %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)(                                                         
 2009b00:	03 00 80 71 	sethi  %hi(0x201c400), %g1                     
 2009b04:	9e 10 61 10 	or  %g1, 0x110, %o7	! 201c510 <__log2table+0x140>
 2009b08:	d6 23 a0 5c 	st  %o3, [ %sp + 0x5c ]                        
 2009b0c:	d8 23 a0 60 	st  %o4, [ %sp + 0x60 ]                        
 2009b10:	de 23 a0 64 	st  %o7, [ %sp + 0x64 ]                        
 2009b14:	90 10 00 16 	mov  %l6, %o0                                  
 2009b18:	92 10 20 00 	clr  %o1                                       
 2009b1c:	94 10 00 15 	mov  %l5, %o2                                  
 2009b20:	96 10 00 19 	mov  %i1, %o3                                  
 2009b24:	9f c7 40 00 	call  %i5                                      
 2009b28:	98 10 00 14 	mov  %l4, %o4                                  
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
 2009b2c:	da 04 c0 00 	ld  [ %l3 ], %o5                               
 2009b30:	80 a5 00 0d 	cmp  %l4, %o5                                  
 2009b34:	02 80 00 0c 	be  2009b64 <_Heap_Walk+0x45c>                 
 2009b38:	80 a4 a0 00 	cmp  %l2, 0                                    
    (*printer)(                                                       
 2009b3c:	e6 23 a0 5c 	st  %l3, [ %sp + 0x5c ]                        
 2009b40:	90 10 00 16 	mov  %l6, %o0                                  
 2009b44:	92 10 20 01 	mov  1, %o1                                    
 2009b48:	15 00 80 72 	sethi  %hi(0x201c800), %o2                     
 2009b4c:	96 10 00 19 	mov  %i1, %o3                                  
 2009b50:	94 12 a0 80 	or  %o2, 0x80, %o2                             
 2009b54:	9f c7 40 00 	call  %i5                                      
 2009b58:	98 10 00 14 	mov  %l4, %o4                                  
        "block 0x%08x: next block 0x%08x is not a successor\n",       
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
 2009b5c:	10 bf ff ce 	b  2009a94 <_Heap_Walk+0x38c>                  
 2009b60:	b0 10 20 00 	clr  %i0                                       
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
 2009b64:	32 80 00 0a 	bne,a   2009b8c <_Heap_Walk+0x484>             
 2009b68:	c6 06 20 08 	ld  [ %i0 + 8 ], %g3                           
    (*printer)(                                                       
 2009b6c:	15 00 80 72 	sethi  %hi(0x201c800), %o2                     
 2009b70:	90 10 00 16 	mov  %l6, %o0                                  
 2009b74:	92 10 20 01 	mov  1, %o1                                    
 2009b78:	10 80 00 26 	b  2009c10 <_Heap_Walk+0x508>                  
 2009b7c:	94 12 a0 c0 	or  %o2, 0xc0, %o2                             
{                                                                     
  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 ) {                            
    if ( free_block == block ) {                                      
 2009b80:	22 80 00 19 	be,a   2009be4 <_Heap_Walk+0x4dc>              
 2009b84:	b2 10 00 13 	mov  %l3, %i1                                  
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
 2009b88:	c6 00 e0 08 	ld  [ %g3 + 8 ], %g3                           
)                                                                     
{                                                                     
  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 ) {                            
 2009b8c:	80 a0 c0 18 	cmp  %g3, %i0                                  
 2009b90:	12 bf ff fc 	bne  2009b80 <_Heap_Walk+0x478>                
 2009b94:	80 a0 c0 19 	cmp  %g3, %i1                                  
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
 2009b98:	10 80 00 1b 	b  2009c04 <_Heap_Walk+0x4fc>                  
 2009b9c:	15 00 80 72 	sethi  %hi(0x201c800), %o2                     
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
 2009ba0:	80 a4 a0 00 	cmp  %l2, 0                                    
 2009ba4:	02 80 00 09 	be  2009bc8 <_Heap_Walk+0x4c0>                 
 2009ba8:	92 10 20 00 	clr  %o1                                       
      (*printer)(                                                     
 2009bac:	15 00 80 72 	sethi  %hi(0x201c800), %o2                     
 2009bb0:	96 10 00 19 	mov  %i1, %o3                                  
 2009bb4:	94 12 a0 f0 	or  %o2, 0xf0, %o2                             
 2009bb8:	9f c7 40 00 	call  %i5                                      
 2009bbc:	98 10 00 14 	mov  %l4, %o4                                  
 2009bc0:	10 80 00 09 	b  2009be4 <_Heap_Walk+0x4dc>                  
 2009bc4:	b2 10 00 13 	mov  %l3, %i1                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
 2009bc8:	da 06 40 00 	ld  [ %i1 ], %o5                               
 2009bcc:	15 00 80 72 	sethi  %hi(0x201c800), %o2                     
 2009bd0:	96 10 00 19 	mov  %i1, %o3                                  
 2009bd4:	94 12 a1 08 	or  %o2, 0x108, %o2                            
 2009bd8:	9f c7 40 00 	call  %i5                                      
 2009bdc:	98 10 00 14 	mov  %l4, %o4                                  
 2009be0:	b2 10 00 13 	mov  %l3, %i1                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
 2009be4:	80 a4 c0 1a 	cmp  %l3, %i2                                  
 2009be8:	32 bf ff 68 	bne,a   2009988 <_Heap_Walk+0x280>             
 2009bec:	e4 06 60 04 	ld  [ %i1 + 4 ], %l2                           
 2009bf0:	10 80 00 02 	b  2009bf8 <_Heap_Walk+0x4f0>                  
 2009bf4:	b0 10 20 01 	mov  1, %i0                                    
 2009bf8:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
 2009bfc:	81 c7 e0 08 	ret                                            
 2009c00:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
 2009c04:	90 10 00 16 	mov  %l6, %o0                                  
 2009c08:	92 10 20 01 	mov  1, %o1                                    
 2009c0c:	94 12 a1 30 	or  %o2, 0x130, %o2                            
 2009c10:	96 10 00 19 	mov  %i1, %o3                                  
 2009c14:	9f c7 40 00 	call  %i5                                      
 2009c18:	b0 10 20 00 	clr  %i0                                       
 2009c1c:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
 2009c20:	81 c7 e0 08 	ret                                            
 2009c24:	81 e8 00 00 	restore                                        
                                                                      

02008afc <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) {
 2008afc:	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 );   
 2008b00:	13 00 80 2a 	sethi  %hi(0x200a800), %o1                     
 2008b04:	90 07 bf f4 	add  %fp, -12, %o0                             
 2008b08:	92 12 63 b8 	or  %o1, 0x3b8, %o1                            
  Internal_errors_Source source,                                      
  bool                   is_internal,                                 
  Internal_errors_t      error                                        
)                                                                     
{                                                                     
  User_extensions_Fatal_context ctx = { source, is_internal, error }; 
 2008b0c:	f0 27 bf f4 	st  %i0, [ %fp + -12 ]                         
 2008b10:	f2 2f bf f8 	stb  %i1, [ %fp + -8 ]                         
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );   
 2008b14:	40 00 08 34 	call  200abe4 <_User_extensions_Iterate>       
 2008b18:	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;            
 2008b1c:	05 00 80 76 	sethi  %hi(0x201d800), %g2                     <== NOT EXECUTED
 2008b20:	82 10 a2 dc 	or  %g2, 0x2dc, %g1	! 201dadc <_Internal_errors_What_happened><== NOT EXECUTED
 2008b24:	f0 20 a2 dc 	st  %i0, [ %g2 + 0x2dc ]                       <== NOT EXECUTED
  _Internal_errors_What_happened.is_internal = is_internal;           
 2008b28:	f2 28 60 04 	stb  %i1, [ %g1 + 4 ]                          <== NOT EXECUTED
  _Internal_errors_What_happened.the_error   = the_error;             
 2008b2c:	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;                                      
 2008b30:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
 2008b34:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     <== NOT EXECUTED
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
 2008b38:	7f ff e6 a3 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2008b3c:	c4 20 62 e8 	st  %g2, [ %g1 + 0x2e8 ]	! 201dae8 <_System_state_Current><== NOT EXECUTED
 2008b40:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
 2008b44:	30 80 00 00 	b,a   2008b44 <_Internal_error_Occurred+0x48>  <== NOT EXECUTED
                                                                      

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

02008fe0 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) {
 2008fe0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
 2008fe4:	80 a6 60 00 	cmp  %i1, 0                                    
 2008fe8:	12 80 00 04 	bne  2008ff8 <_Objects_Get_information+0x18>   
 2008fec:	01 00 00 00 	nop                                            
    return NULL;                                                      
 2008ff0:	81 c7 e0 08 	ret                                            
 2008ff4:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  /*                                                                  
   *  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 );      
 2008ff8:	40 00 12 45 	call  200d90c <_Objects_API_maximum_class>     
 2008ffc:	90 10 00 18 	mov  %i0, %o0                                  
  if ( the_class_api_maximum == 0 )                                   
 2009000:	80 a2 20 00 	cmp  %o0, 0                                    
 2009004:	02 bf ff fb 	be  2008ff0 <_Objects_Get_information+0x10>    
 2009008:	80 a6 40 08 	cmp  %i1, %o0                                  
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
 200900c:	18 bf ff f9 	bgu  2008ff0 <_Objects_Get_information+0x10>   
 2009010:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
 2009014:	b1 2e 20 02 	sll  %i0, 2, %i0                               
 2009018:	82 10 61 34 	or  %g1, 0x134, %g1                            
 200901c:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
 2009020:	80 a0 60 00 	cmp  %g1, 0                                    
 2009024:	02 bf ff f3 	be  2008ff0 <_Objects_Get_information+0x10>    <== NEVER TAKEN
 2009028:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
 200902c:	f0 00 40 19 	ld  [ %g1 + %i1 ], %i0                         
  if ( !info )                                                        
 2009030:	80 a6 20 00 	cmp  %i0, 0                                    
 2009034:	02 bf ff ef 	be  2008ff0 <_Objects_Get_information+0x10>    <== NEVER TAKEN
 2009038:	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 )                                         
 200903c:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
 2009040:	80 a0 60 00 	cmp  %g1, 0                                    
 2009044:	02 bf ff eb 	be  2008ff0 <_Objects_Get_information+0x10>    
 2009048:	01 00 00 00 	nop                                            
      return NULL;                                                    
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
 200904c:	81 c7 e0 08 	ret                                            
 2009050:	81 e8 00 00 	restore                                        
                                                                      

0201b3d8 <_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;
 201b3d8:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
 201b3dc:	92 22 40 01 	sub  %o1, %g1, %o1                             
                                                                      
  if ( information->maximum >= index ) {                              
 201b3e0:	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;                           
 201b3e4:	92 02 60 01 	inc  %o1                                       
                                                                      
  if ( information->maximum >= index ) {                              
 201b3e8:	80 a0 40 09 	cmp  %g1, %o1                                  
 201b3ec:	0a 80 00 09 	bcs  201b410 <_Objects_Get_no_protection+0x38> 
 201b3f0:	93 2a 60 02 	sll  %o1, 2, %o1                               
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
 201b3f4:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
 201b3f8:	d0 00 40 09 	ld  [ %g1 + %o1 ], %o0                         
 201b3fc:	80 a2 20 00 	cmp  %o0, 0                                    
 201b400:	02 80 00 05 	be  201b414 <_Objects_Get_no_protection+0x3c>  <== NEVER TAKEN
 201b404:	82 10 20 01 	mov  1, %g1                                    
      *location = OBJECTS_LOCAL;                                      
      return the_object;                                              
 201b408:	81 c3 e0 08 	retl                                           
 201b40c:	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;                                          
 201b410:	82 10 20 01 	mov  1, %g1                                    
  return NULL;                                                        
 201b414:	90 10 20 00 	clr  %o0                                       
}                                                                     
 201b418:	81 c3 e0 08 	retl                                           
 201b41c:	c2 22 80 00 	st  %g1, [ %o2 ]                               
                                                                      

0200d0e8 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) {
 200d0e8:	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;
 200d0ec:	80 a6 20 00 	cmp  %i0, 0                                    
 200d0f0:	12 80 00 06 	bne  200d108 <_Objects_Id_to_name+0x20>        
 200d0f4:	83 36 20 18 	srl  %i0, 0x18, %g1                            
 200d0f8:	03 00 80 b7 	sethi  %hi(0x202dc00), %g1                     
 200d0fc:	c2 00 63 30 	ld  [ %g1 + 0x330 ], %g1	! 202df30 <_Per_CPU_Information+0x10>
 200d100:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
 200d104:	83 36 20 18 	srl  %i0, 0x18, %g1                            
 200d108:	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 )                      
 200d10c:	84 00 7f ff 	add  %g1, -1, %g2                              
 200d110:	80 a0 a0 02 	cmp  %g2, 2                                    
 200d114:	08 80 00 18 	bleu  200d174 <_Objects_Id_to_name+0x8c>       
 200d118:	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;                                        
 200d11c:	81 c7 e0 08 	ret                                            
 200d120:	91 e8 20 03 	restore  %g0, 3, %o0                           
  if ( !_Objects_Information_table[ the_api ] )                       
    return OBJECTS_INVALID_ID;                                        
                                                                      
  the_class = _Objects_Get_class( tmpId );                            
                                                                      
  information = _Objects_Information_table[ the_api ][ the_class ];   
 200d124:	85 28 a0 02 	sll  %g2, 2, %g2                               
 200d128:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
  if ( !information )                                                 
 200d12c:	80 a2 20 00 	cmp  %o0, 0                                    
 200d130:	02 bf ff fb 	be  200d11c <_Objects_Id_to_name+0x34>         <== NEVER TAKEN
 200d134:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    if ( information->is_string )                                     
 200d138:	c2 0a 20 38 	ldub  [ %o0 + 0x38 ], %g1                      
 200d13c:	80 a0 60 00 	cmp  %g1, 0                                    
 200d140:	12 bf ff f7 	bne  200d11c <_Objects_Id_to_name+0x34>        <== NEVER TAKEN
 200d144:	92 10 00 18 	mov  %i0, %o1                                  
      return OBJECTS_INVALID_ID;                                      
  #endif                                                              
                                                                      
  the_object = _Objects_Get( information, tmpId, &ignored_location ); 
 200d148:	7f ff ff cb 	call  200d074 <_Objects_Get>                   
 200d14c:	94 07 bf fc 	add  %fp, -4, %o2                              
  if ( !the_object )                                                  
 200d150:	80 a2 20 00 	cmp  %o0, 0                                    
 200d154:	02 bf ff f2 	be  200d11c <_Objects_Id_to_name+0x34>         
 200d158:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
 200d15c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
 200d160:	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();                                          
 200d164:	40 00 03 d0 	call  200e0a4 <_Thread_Enable_dispatch>        
 200d168:	c2 26 40 00 	st  %g1, [ %i1 ]                               
 200d16c:	81 c7 e0 08 	ret                                            
 200d170:	81 e8 00 00 	restore                                        
                                                                      
  the_api = _Objects_Get_API( tmpId );                                
  if ( !_Objects_Is_api_valid( the_api ) )                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
 200d174:	05 00 80 b6 	sethi  %hi(0x202d800), %g2                     
 200d178:	84 10 a1 24 	or  %g2, 0x124, %g2	! 202d924 <_Objects_Information_table>
 200d17c:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 200d180:	80 a0 60 00 	cmp  %g1, 0                                    
 200d184:	12 bf ff e8 	bne  200d124 <_Objects_Id_to_name+0x3c>        
 200d188:	85 36 20 1b 	srl  %i0, 0x1b, %g2                            
 200d18c:	30 bf ff e4 	b,a   200d11c <_Objects_Id_to_name+0x34>       
                                                                      

0200ee88 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) {
 200ee88:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
 200ee8c:	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 ];     
 200ee90:	39 00 00 3f 	sethi  %hi(0xfc00), %i4                        
 200ee94:	b5 30 60 18 	srl  %g1, 0x18, %i2                            
 200ee98:	b8 17 23 ff 	or  %i4, 0x3ff, %i4                            
 200ee9c:	b4 0e a0 07 	and  %i2, 7, %i2                               
 200eea0:	b8 08 40 1c 	and  %g1, %i4, %i4                             
 200eea4:	b4 06 a0 04 	add  %i2, 4, %i2                               
 200eea8:	b9 2f 20 02 	sll  %i4, 2, %i4                               
   *                                                                  
   *  Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.         
   */                                                                 
  while ( !done ) {                                                   
    Objects_Maximum index = 0;                                        
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
 200eeac:	37 00 80 76 	sethi  %hi(0x201d800), %i3                     
    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 ];     
 200eeb0:	b5 2e a0 02 	sll  %i2, 2, %i2                               
   *                                                                  
   *  Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.         
   */                                                                 
  while ( !done ) {                                                   
    Objects_Maximum index = 0;                                        
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
 200eeb4:	82 16 e1 bc 	or  %i3, 0x1bc, %g1                            
                                                                      
    done = true;                                                      
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
 200eeb8:	ba 10 20 01 	mov  1, %i5                                    
   */                                                                 
  while ( !done ) {                                                   
    Objects_Maximum index = 0;                                        
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
                                                                      
    done = true;                                                      
 200eebc:	84 10 20 01 	mov  1, %g2                                    
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
 200eec0:	10 80 00 18 	b  200ef20 <_POSIX_Keys_Run_destructors+0x98>  
 200eec4:	f2 10 60 10 	lduh  [ %g1 + 0x10 ], %i1                      
      POSIX_Keys_Control *key = (POSIX_Keys_Control *)                
        _POSIX_Keys_Information.local_table [ index ];                
 200eec8:	86 16 e1 bc 	or  %i3, 0x1bc, %g3                            
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
                                                                      
    done = true;                                                      
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
      POSIX_Keys_Control *key = (POSIX_Keys_Control *)                
 200eecc:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
 200eed0:	83 28 60 02 	sll  %g1, 2, %g1                               
 200eed4:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
        _POSIX_Keys_Information.local_table [ index ];                
                                                                      
      if ( key != NULL && key->destructor != NULL ) {                 
 200eed8:	80 a0 60 00 	cmp  %g1, 0                                    
 200eedc:	22 80 00 11 	be,a   200ef20 <_POSIX_Keys_Run_destructors+0x98>
 200eee0:	ba 07 60 01 	inc  %i5                                       
 200eee4:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
 200eee8:	80 a0 e0 00 	cmp  %g3, 0                                    
 200eeec:	02 80 00 0c 	be  200ef1c <_POSIX_Keys_Run_destructors+0x94> 
 200eef0:	86 00 40 1a 	add  %g1, %i2, %g3                             
        void *value = key->Values [ thread_api ][ thread_index ];     
 200eef4:	c6 00 e0 04 	ld  [ %g3 + 4 ], %g3                           
 200eef8:	d0 00 c0 1c 	ld  [ %g3 + %i4 ], %o0                         
                                                                      
        if ( value != NULL ) {                                        
 200eefc:	80 a2 20 00 	cmp  %o0, 0                                    
 200ef00:	22 80 00 08 	be,a   200ef20 <_POSIX_Keys_Run_destructors+0x98><== ALWAYS TAKEN
 200ef04:	ba 07 60 01 	inc  %i5                                       
          key->Values [ thread_api ][ thread_index ] = NULL;          
 200ef08:	c0 20 c0 1c 	clr  [ %g3 + %i4 ]                             <== NOT EXECUTED
          (*key->destructor)( value );                                
 200ef0c:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        <== NOT EXECUTED
 200ef10:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 200ef14:	01 00 00 00 	nop                                            <== NOT EXECUTED
          done = false;                                               
 200ef18:	84 10 20 00 	clr  %g2	! 0 <PROM_START>                      <== NOT EXECUTED
    Objects_Maximum index = 0;                                        
    Objects_Maximum max = _POSIX_Keys_Information.maximum;            
                                                                      
    done = true;                                                      
                                                                      
    for ( index = 1 ; index <= max ; ++index ) {                      
 200ef1c:	ba 07 60 01 	inc  %i5                                       
 200ef20:	83 2f 60 10 	sll  %i5, 0x10, %g1                            
 200ef24:	83 30 60 10 	srl  %g1, 0x10, %g1                            
 200ef28:	80 a0 40 19 	cmp  %g1, %i1                                  
 200ef2c:	08 bf ff e7 	bleu  200eec8 <_POSIX_Keys_Run_destructors+0x40>
 200ef30:	80 88 a0 ff 	btst  0xff, %g2                                
   *  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 ) {                                                   
 200ef34:	02 bf ff e1 	be  200eeb8 <_POSIX_Keys_Run_destructors+0x30> <== NEVER TAKEN
 200ef38:	82 16 e1 bc 	or  %i3, 0x1bc, %g1                            
          done = false;                                               
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
}                                                                     
 200ef3c:	81 c7 e0 08 	ret                                            
 200ef40:	81 e8 00 00 	restore                                        
                                                                      

0200c850 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) {
 200c850:	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(             
 200c854:	11 00 80 a9 	sethi  %hi(0x202a400), %o0                     
 200c858:	92 10 00 18 	mov  %i0, %o1                                  
 200c85c:	90 12 23 e0 	or  %o0, 0x3e0, %o0                            
 200c860:	40 00 0c d5 	call  200fbb4 <_Objects_Get>                   
 200c864:	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 ) {                                               
 200c868:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200c86c:	80 a0 60 00 	cmp  %g1, 0                                    
 200c870:	12 80 00 40 	bne  200c970 <_POSIX_Message_queue_Receive_support+0x120>
 200c874:	01 00 00 00 	nop                                            
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {             
 200c878:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
 200c87c:	84 08 60 03 	and  %g1, 3, %g2                               
 200c880:	80 a0 a0 01 	cmp  %g2, 1                                    
 200c884:	32 80 00 05 	bne,a   200c898 <_POSIX_Message_queue_Receive_support+0x48>
 200c888:	d0 02 20 10 	ld  [ %o0 + 0x10 ], %o0                        
        _Thread_Enable_dispatch();                                    
 200c88c:	40 00 10 a8 	call  2010b2c <_Thread_Enable_dispatch>        
 200c890:	01 00 00 00 	nop                                            
 200c894:	30 80 00 37 	b,a   200c970 <_POSIX_Message_queue_Receive_support+0x120>
        rtems_set_errno_and_return_minus_one( EBADF );                
      }                                                               
                                                                      
      the_mq = the_mq_fd->Queue;                                      
                                                                      
      if ( msg_len < the_mq->Message_queue.maximum_message_size ) {   
 200c898:	c4 02 20 68 	ld  [ %o0 + 0x68 ], %g2                        
 200c89c:	80 a6 80 02 	cmp  %i2, %g2                                  
 200c8a0:	1a 80 00 08 	bcc  200c8c0 <_POSIX_Message_queue_Receive_support+0x70>
 200c8a4:	84 10 3f ff 	mov  -1, %g2                                   
        _Thread_Enable_dispatch();                                    
 200c8a8:	40 00 10 a1 	call  2010b2c <_Thread_Enable_dispatch>        
 200c8ac:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one( EMSGSIZE );             
 200c8b0:	40 00 28 1f 	call  201692c <__errno>                        
 200c8b4:	01 00 00 00 	nop                                            
 200c8b8:	10 80 00 31 	b  200c97c <_POSIX_Message_queue_Receive_support+0x12c>
 200c8bc:	82 10 20 7a 	mov  0x7a, %g1	! 7a <PROM_START+0x7a>          
      /*                                                              
       *  Now if something goes wrong, we return a "length" of -1     
       *  to indicate an error.                                       
       */                                                             
                                                                      
      length_out = -1;                                                
 200c8c0:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
                                                                      
      /*                                                              
       *  A timed receive with a bad time will do a poll regardless.  
       */                                                             
      if ( wait )                                                     
 200c8c4:	80 a7 20 00 	cmp  %i4, 0                                    
 200c8c8:	02 80 00 05 	be  200c8dc <_POSIX_Message_queue_Receive_support+0x8c>
 200c8cc:	98 10 20 00 	clr  %o4                                       
        do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;     
 200c8d0:	99 30 60 0e 	srl  %g1, 0xe, %o4                             
 200c8d4:	98 1b 20 01 	xor  %o4, 1, %o4                               
 200c8d8:	98 0b 20 01 	and  %o4, 1, %o4                               
        do_wait = wait;                                               
                                                                      
      /*                                                              
       *  Now perform the actual message receive                      
       */                                                             
      _CORE_message_queue_Seize(                                      
 200c8dc:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
 200c8e0:	92 10 00 18 	mov  %i0, %o1                                  
 200c8e4:	94 10 00 19 	mov  %i1, %o2                                  
 200c8e8:	96 07 bf fc 	add  %fp, -4, %o3                              
 200c8ec:	98 0b 20 01 	and  %o4, 1, %o4                               
 200c8f0:	40 00 08 7e 	call  200eae8 <_CORE_message_queue_Seize>      
 200c8f4:	9a 10 00 1d 	mov  %i5, %o5                                  
        &length_out,                                                  
        do_wait,                                                      
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
 200c8f8:	40 00 10 8d 	call  2010b2c <_Thread_Enable_dispatch>        
 200c8fc:	01 00 00 00 	nop                                            
      if (msg_prio) {                                                 
 200c900:	80 a6 e0 00 	cmp  %i3, 0                                    
 200c904:	02 80 00 08 	be  200c924 <_POSIX_Message_queue_Receive_support+0xd4><== NEVER TAKEN
 200c908:	03 00 80 aa 	sethi  %hi(0x202a800), %g1                     
        *msg_prio = _POSIX_Message_queue_Priority_from_core(          
             _Thread_Executing->Wait.count                            
 200c90c:	c2 00 60 70 	ld  [ %g1 + 0x70 ], %g1	! 202a870 <_Per_CPU_Information+0x10>
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);     
 200c910:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
 200c914:	83 38 a0 1f 	sra  %g2, 0x1f, %g1                            
 200c918:	84 18 40 02 	xor  %g1, %g2, %g2                             
 200c91c:	82 20 80 01 	sub  %g2, %g1, %g1                             
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if (msg_prio) {                                                 
        *msg_prio = _POSIX_Message_queue_Priority_from_core(          
 200c920:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
             _Thread_Executing->Wait.count                            
          );                                                          
      }                                                               
                                                                      
      if ( !_Thread_Executing->Wait.return_code )                     
 200c924:	3b 00 80 aa 	sethi  %hi(0x202a800), %i5                     
 200c928:	ba 17 60 60 	or  %i5, 0x60, %i5	! 202a860 <_Per_CPU_Information>
 200c92c:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200c930:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
 200c934:	80 a0 60 00 	cmp  %g1, 0                                    
 200c938:	12 80 00 05 	bne  200c94c <_POSIX_Message_queue_Receive_support+0xfc>
 200c93c:	01 00 00 00 	nop                                            
        return length_out;                                            
 200c940:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
 200c944:	81 c7 e0 08 	ret                                            
 200c948:	81 e8 00 00 	restore                                        
                                                                      
      rtems_set_errno_and_return_minus_one(                           
 200c94c:	40 00 27 f8 	call  201692c <__errno>                        
 200c950:	b0 10 3f ff 	mov  -1, %i0                                   
 200c954:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200c958:	b8 10 00 08 	mov  %o0, %i4                                  
 200c95c:	40 00 00 96 	call  200cbb4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
 200c960:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
 200c964:	d0 27 00 00 	st  %o0, [ %i4 ]                               
 200c968:	81 c7 e0 08 	ret                                            
 200c96c:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EBADF );                      
 200c970:	40 00 27 ef 	call  201692c <__errno>                        
 200c974:	01 00 00 00 	nop                                            
 200c978:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
 200c97c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200c980:	b0 10 3f ff 	mov  -1, %i0                                   
}                                                                     
 200c984:	81 c7 e0 08 	ret                                            
 200c988:	81 e8 00 00 	restore                                        
                                                                      

0200ec78 <_POSIX_Semaphore_Create_support>: size_t name_len, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) {
 200ec78:	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)                                                   
 200ec7c:	80 a6 a0 00 	cmp  %i2, 0                                    
 200ec80:	22 80 00 06 	be,a   200ec98 <_POSIX_Semaphore_Create_support+0x20>
 200ec84:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
 200ec88:	40 00 0a 42 	call  2011590 <__errno>                        
 200ec8c:	01 00 00 00 	nop                                            
 200ec90:	10 80 00 10 	b  200ecd0 <_POSIX_Semaphore_Create_support+0x58>
 200ec94:	82 10 20 58 	mov  0x58, %g1	! 58 <PROM_START+0x58>          
   *                                                                  
   * 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;                  
 200ec98:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2                        
                                                                      
    ++level;                                                          
 200ec9c:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 200eca0:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
 *  _POSIX_Semaphore_Allocate                                         
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{                                                                     
  return (POSIX_Semaphore_Control *)                                  
 200eca4:	21 00 80 88 	sethi  %hi(0x2022000), %l0                     
 200eca8:	7f ff ee d9 	call  200a80c <_Objects_Allocate>              
 200ecac:	90 14 23 64 	or  %l0, 0x364, %o0	! 2022364 <_POSIX_Semaphore_Information>
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_semaphore = _POSIX_Semaphore_Allocate();                        
  if ( !the_semaphore ) {                                             
 200ecb0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200ecb4:	12 80 00 0a 	bne  200ecdc <_POSIX_Semaphore_Create_support+0x64>
 200ecb8:	80 a6 20 00 	cmp  %i0, 0                                    
    _Thread_Enable_dispatch();                                        
 200ecbc:	7f ff f4 0b 	call  200bce8 <_Thread_Enable_dispatch>        
 200ecc0:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSPC );                   
 200ecc4:	40 00 0a 33 	call  2011590 <__errno>                        
 200ecc8:	01 00 00 00 	nop                                            
 200eccc:	82 10 20 1c 	mov  0x1c, %g1	! 1c <PROM_START+0x1c>          
 200ecd0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200ecd4:	81 c7 e0 08 	ret                                            
 200ecd8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      
  /*                                                                  
   * Make a copy of the user's string for name just in case it was    
   * dynamically constructed.                                         
   */                                                                 
  if ( name_arg != NULL ) {                                           
 200ecdc:	02 80 00 10 	be  200ed1c <_POSIX_Semaphore_Create_support+0xa4>
 200ece0:	90 10 00 18 	mov  %i0, %o0                                  
    name = _Workspace_String_duplicate( name_arg, name_len );         
 200ece4:	40 00 04 45 	call  200fdf8 <_Workspace_String_duplicate>    
 200ece8:	92 10 00 19 	mov  %i1, %o1                                  
    if ( !name ) {                                                    
 200ecec:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 200ecf0:	12 80 00 0d 	bne  200ed24 <_POSIX_Semaphore_Create_support+0xac><== ALWAYS TAKEN
 200ecf4:	80 a6 a0 00 	cmp  %i2, 0                                    
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (                     
  POSIX_Semaphore_Control *the_semaphore                              
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
 200ecf8:	90 14 23 64 	or  %l0, 0x364, %o0                            <== NOT EXECUTED
 200ecfc:	7f ff ef a3 	call  200ab88 <_Objects_Free>                  <== NOT EXECUTED
 200ed00:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
      _POSIX_Semaphore_Free( the_semaphore );                         
      _Thread_Enable_dispatch();                                      
 200ed04:	7f ff f3 f9 	call  200bce8 <_Thread_Enable_dispatch>        <== NOT EXECUTED
 200ed08:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
 200ed0c:	40 00 0a 21 	call  2011590 <__errno>                        <== NOT EXECUTED
 200ed10:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200ed14:	10 bf ff ef 	b  200ecd0 <_POSIX_Semaphore_Create_support+0x58><== NOT EXECUTED
 200ed18:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
    }                                                                 
  } else {                                                            
    name = NULL;                                                      
 200ed1c:	b4 10 20 00 	clr  %i2                                       
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
                                                                      
  if ( name ) {                                                       
 200ed20:	80 a6 a0 00 	cmp  %i2, 0                                    
 200ed24:	02 80 00 08 	be  200ed44 <_POSIX_Semaphore_Create_support+0xcc>
 200ed28:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
    the_semaphore->named = true;                                      
 200ed2c:	82 10 20 01 	mov  1, %g1                                    
 200ed30:	c2 2f 60 14 	stb  %g1, [ %i5 + 0x14 ]                       
    the_semaphore->open_count = 1;                                    
 200ed34:	82 10 20 01 	mov  1, %g1                                    
 200ed38:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
    the_semaphore->linked = true;                                     
 200ed3c:	10 80 00 05 	b  200ed50 <_POSIX_Semaphore_Create_support+0xd8>
 200ed40:	c2 2f 60 15 	stb  %g1, [ %i5 + 0x15 ]                       
  } else {                                                            
    the_semaphore->named = false;                                     
 200ed44:	c0 2f 60 14 	clrb  [ %i5 + 0x14 ]                           
    the_semaphore->open_count = 0;                                    
 200ed48:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
    the_semaphore->linked = false;                                    
 200ed4c:	c0 2f 60 15 	clrb  [ %i5 + 0x15 ]                           
  the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;         
                                                                      
  /*                                                                  
   *  This effectively disables limit checking.                       
   */                                                                 
  the_sem_attr->maximum_count = 0xFFFFFFFF;                           
 200ed50:	82 10 3f ff 	mov  -1, %g1                                   
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
 200ed54:	90 07 60 1c 	add  %i5, 0x1c, %o0                            
  the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;         
                                                                      
  /*                                                                  
   *  This effectively disables limit checking.                       
   */                                                                 
  the_sem_attr->maximum_count = 0xFFFFFFFF;                           
 200ed58:	c2 27 60 5c 	st  %g1, [ %i5 + 0x5c ]                        
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
 200ed5c:	92 07 60 5c 	add  %i5, 0x5c, %o1                            
 200ed60:	94 10 00 1b 	mov  %i3, %o2                                  
 200ed64:	7f ff ed 1f 	call  200a1e0 <_CORE_semaphore_Initialize>     
 200ed68:	c0 27 60 60 	clr  [ %i5 + 0x60 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 200ed6c:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 200ed70:	05 00 80 88 	sethi  %hi(0x2022000), %g2                     
 200ed74:	c4 00 a3 80 	ld  [ %g2 + 0x380 ], %g2	! 2022380 <_POSIX_Semaphore_Information+0x1c>
 200ed78:	83 28 60 02 	sll  %g1, 2, %g1                               
 200ed7c:	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;                                   
 200ed80:	f4 27 60 0c 	st  %i2, [ %i5 + 0xc ]                         
    &_POSIX_Semaphore_Information,                                    
    &the_semaphore->Object,                                           
    name                                                              
  );                                                                  
                                                                      
  *the_sem = the_semaphore;                                           
 200ed84:	fa 27 00 00 	st  %i5, [ %i4 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
 200ed88:	7f ff f3 d8 	call  200bce8 <_Thread_Enable_dispatch>        
 200ed8c:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
 200ed90:	81 c7 e0 08 	ret                                            
 200ed94:	81 e8 00 00 	restore                                        
                                                                      

0200c75c <_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 ];
 200c75c:	c2 02 21 5c 	ld  [ %o0 + 0x15c ], %g1                       
                                                                      
  if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
 200c760:	c4 00 60 d8 	ld  [ %g1 + 0xd8 ], %g2                        
 200c764:	80 a0 a0 00 	cmp  %g2, 0                                    
 200c768:	12 80 00 12 	bne  200c7b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54><== NEVER TAKEN
 200c76c:	01 00 00 00 	nop                                            
 200c770:	c4 00 60 dc 	ld  [ %g1 + 0xdc ], %g2                        
 200c774:	80 a0 a0 01 	cmp  %g2, 1                                    
 200c778:	12 80 00 0e 	bne  200c7b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
 200c77c:	01 00 00 00 	nop                                            
       thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
 200c780:	c2 00 60 e0 	ld  [ %g1 + 0xe0 ], %g1                        
 200c784:	80 a0 60 00 	cmp  %g1, 0                                    
 200c788:	02 80 00 0a 	be  200c7b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
 200c78c:	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;                  
 200c790:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 200c794:	c4 00 62 30 	ld  [ %g1 + 0x230 ], %g2	! 201da30 <_Thread_Dispatch_disable_level>
       thread_support->cancelation_requested ) {                      
    _Thread_Unnest_dispatch();                                        
    _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );               
 200c798:	92 10 3f ff 	mov  -1, %o1                                   
                                                                      
    --level;                                                          
 200c79c:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
 200c7a0:	c4 20 62 30 	st  %g2, [ %g1 + 0x230 ]                       
 200c7a4:	82 13 c0 00 	mov  %o7, %g1                                  
 200c7a8:	40 00 01 b5 	call  200ce7c <_POSIX_Thread_Exit>             
 200c7ac:	9e 10 40 00 	mov  %g1, %o7                                  
  } else                                                              
    _Thread_Enable_dispatch();                                        
 200c7b0:	82 13 c0 00 	mov  %o7, %g1                                  
 200c7b4:	7f ff f6 54 	call  200a104 <_Thread_Enable_dispatch>        
 200c7b8:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

0200db0c <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) {
 200db0c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )           
 200db10:	7f ff ff f4 	call  200dae0 <_POSIX_Priority_Is_valid>       
 200db14:	d0 06 40 00 	ld  [ %i1 ], %o0                               
 200db18:	80 8a 20 ff 	btst  0xff, %o0                                
 200db1c:	32 80 00 04 	bne,a   200db2c <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
 200db20:	c0 26 80 00 	clr  [ %i2 ]                                   
    return EINVAL;                                                    
 200db24:	81 c7 e0 08 	ret                                            
 200db28:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
                                                                      
  *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;               
  *budget_callout = NULL;                                             
                                                                      
  if ( policy == SCHED_OTHER ) {                                      
 200db2c:	80 a6 20 00 	cmp  %i0, 0                                    
 200db30:	12 80 00 06 	bne  200db48 <_POSIX_Thread_Translate_sched_param+0x3c>
 200db34:	c0 26 c0 00 	clr  [ %i3 ]                                   
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;  
 200db38:	82 10 20 01 	mov  1, %g1                                    
 200db3c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    return 0;                                                         
 200db40:	81 c7 e0 08 	ret                                            
 200db44:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  if ( policy == SCHED_FIFO ) {                                       
 200db48:	80 a6 20 01 	cmp  %i0, 1                                    
 200db4c:	02 80 00 29 	be  200dbf0 <_POSIX_Thread_Translate_sched_param+0xe4>
 200db50:	80 a6 20 02 	cmp  %i0, 2                                    
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;             
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_RR ) {                                         
 200db54:	12 80 00 04 	bne  200db64 <_POSIX_Thread_Translate_sched_param+0x58>
 200db58:	80 a6 20 04 	cmp  %i0, 4                                    
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
 200db5c:	10 80 00 25 	b  200dbf0 <_POSIX_Thread_Translate_sched_param+0xe4>
 200db60:	f0 26 80 00 	st  %i0, [ %i2 ]                               
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_SPORADIC ) {                                   
 200db64:	12 bf ff f0 	bne  200db24 <_POSIX_Thread_Translate_sched_param+0x18>
 200db68:	01 00 00 00 	nop                                            
    if ( (param->sched_ss_repl_period.tv_sec == 0) &&                 
 200db6c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 200db70:	80 a0 60 00 	cmp  %g1, 0                                    
 200db74:	32 80 00 07 	bne,a   200db90 <_POSIX_Thread_Translate_sched_param+0x84>
 200db78:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 200db7c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
 200db80:	80 a0 60 00 	cmp  %g1, 0                                    
 200db84:	02 bf ff e8 	be  200db24 <_POSIX_Thread_Translate_sched_param+0x18>
 200db88:	01 00 00 00 	nop                                            
         (param->sched_ss_repl_period.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( (param->sched_ss_init_budget.tv_sec == 0) &&                 
 200db8c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 200db90:	80 a0 60 00 	cmp  %g1, 0                                    
 200db94:	12 80 00 06 	bne  200dbac <_POSIX_Thread_Translate_sched_param+0xa0>
 200db98:	01 00 00 00 	nop                                            
 200db9c:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
 200dba0:	80 a0 60 00 	cmp  %g1, 0                                    
 200dba4:	02 bf ff e0 	be  200db24 <_POSIX_Thread_Translate_sched_param+0x18>
 200dba8:	01 00 00 00 	nop                                            
         (param->sched_ss_init_budget.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <         
 200dbac:	7f ff f7 6b 	call  200b958 <_Timespec_To_ticks>             
 200dbb0:	90 06 60 08 	add  %i1, 8, %o0                               
 200dbb4:	ba 10 00 08 	mov  %o0, %i5                                  
	 _Timespec_To_ticks( ¶m->sched_ss_init_budget ) )                
 200dbb8:	7f ff f7 68 	call  200b958 <_Timespec_To_ticks>             
 200dbbc:	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 ) <         
 200dbc0:	80 a7 40 08 	cmp  %i5, %o0                                  
 200dbc4:	0a bf ff d8 	bcs  200db24 <_POSIX_Thread_Translate_sched_param+0x18>
 200dbc8:	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 ) )  
 200dbcc:	7f ff ff c5 	call  200dae0 <_POSIX_Priority_Is_valid>       
 200dbd0:	d0 06 60 04 	ld  [ %i1 + 4 ], %o0                           
 200dbd4:	80 8a 20 ff 	btst  0xff, %o0                                
 200dbd8:	02 bf ff d3 	be  200db24 <_POSIX_Thread_Translate_sched_param+0x18>
 200dbdc:	82 10 20 03 	mov  3, %g1                                    
      return EINVAL;                                                  
                                                                      
    *budget_algorithm  = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;         
 200dbe0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    *budget_callout = _POSIX_Threads_Sporadic_budget_callout;         
 200dbe4:	03 00 80 1e 	sethi  %hi(0x2007800), %g1                     
 200dbe8:	82 10 63 f4 	or  %g1, 0x3f4, %g1	! 2007bf4 <_POSIX_Threads_Sporadic_budget_callout>
 200dbec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    return 0;                                                         
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
 200dbf0:	81 c7 e0 08 	ret                                            
 200dbf4:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

0200cac8 <_POSIX_Threads_Delete_extension>: */ static void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) {
 200cac8:	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 ];                  
 200cacc:	f0 06 61 5c 	ld  [ %i1 + 0x15c ], %i0                       
                                                                      
  /*                                                                  
   *  Run the POSIX cancellation handlers                             
   */                                                                 
  _POSIX_Threads_cancel_run( deleted );                               
 200cad0:	40 00 08 d4 	call  200ee20 <_POSIX_Threads_cancel_run>      
 200cad4:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  /*                                                                  
   *  Run all the key destructors                                     
   */                                                                 
  _POSIX_Keys_Run_destructors( deleted );                             
 200cad8:	90 10 00 19 	mov  %i1, %o0                                  
 200cadc:	40 00 08 eb 	call  200ee88 <_POSIX_Keys_Run_destructors>    
 200cae0:	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 )) )   
 200cae4:	10 80 00 03 	b  200caf0 <_POSIX_Threads_Delete_extension+0x28>
 200cae8:	f8 06 60 28 	ld  [ %i1 + 0x28 ], %i4                        
      *(void **)the_thread->Wait.return_argument = value_ptr;         
 200caec:	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 )) )   
 200caf0:	7f ff f6 3f 	call  200a3ec <_Thread_queue_Dequeue>          
 200caf4:	90 10 00 1d 	mov  %i5, %o0                                  
 200caf8:	80 a2 20 00 	cmp  %o0, 0                                    
 200cafc:	32 bf ff fc 	bne,a   200caec <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
 200cb00:	c2 02 20 28 	ld  [ %o0 + 0x28 ], %g1                        <== NOT EXECUTED
      *(void **)the_thread->Wait.return_argument = value_ptr;         
                                                                      
  if ( api->schedpolicy == SCHED_SPORADIC )                           
 200cb04:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
 200cb08:	80 a0 60 04 	cmp  %g1, 4                                    
 200cb0c:	32 80 00 05 	bne,a   200cb20 <_POSIX_Threads_Delete_extension+0x58>
 200cb10:	c0 26 61 5c 	clr  [ %i1 + 0x15c ]                           
    (void) _Watchdog_Remove( &api->Sporadic_timer );                  
 200cb14:	7f ff f8 cc 	call  200ae44 <_Watchdog_Remove>               
 200cb18:	90 06 20 a8 	add  %i0, 0xa8, %o0                            
                                                                      
  deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;                 
 200cb1c:	c0 26 61 5c 	clr  [ %i1 + 0x15c ]                           
                                                                      
  _Workspace_Free( api );                                             
 200cb20:	7f ff f9 6a 	call  200b0c8 <_Workspace_Free>                
 200cb24:	81 e8 00 00 	restore                                        
                                                                      

02007950 <_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) {
 2007950:	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;
 2007954:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 2007958:	82 10 63 74 	or  %g1, 0x374, %g1	! 2021774 <Configuration_POSIX_API>
  maximum      = Configuration_POSIX_API.number_of_initialization_threads;
 200795c:	f6 00 60 30 	ld  [ %g1 + 0x30 ], %i3                        
                                                                      
  if ( !user_threads || maximum == 0 )                                
 2007960:	80 a6 e0 00 	cmp  %i3, 0                                    
 2007964:	02 80 00 1d 	be  20079d8 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
 2007968:	fa 00 60 34 	ld  [ %g1 + 0x34 ], %i5                        
 200796c:	80 a7 60 00 	cmp  %i5, 0                                    
 2007970:	02 80 00 1a 	be  20079d8 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
 2007974:	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 );                                
 2007978:	40 00 18 a0 	call  200dbf8 <pthread_attr_init>              
 200797c:	90 07 bf c0 	add  %fp, -64, %o0                             
    (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
 2007980:	92 10 20 02 	mov  2, %o1                                    
 2007984:	40 00 18 a9 	call  200dc28 <pthread_attr_setinheritsched>   
 2007988:	90 07 bf c0 	add  %fp, -64, %o0                             
    (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
 200798c:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
 2007990:	40 00 18 b5 	call  200dc64 <pthread_attr_setstacksize>      
 2007994:	90 07 bf c0 	add  %fp, -64, %o0                             
                                                                      
    status = pthread_create(                                          
 2007998:	d4 07 40 00 	ld  [ %i5 ], %o2                               
 200799c:	90 07 bf bc 	add  %fp, -68, %o0                             
 20079a0:	92 07 bf c0 	add  %fp, -64, %o1                             
 20079a4:	96 10 20 00 	clr  %o3                                       
 20079a8:	7f ff ff 18 	call  2007608 <pthread_create>                 
 20079ac:	ba 07 60 08 	add  %i5, 8, %i5                               
      &thread_id,                                                     
      &attr,                                                          
      user_threads[ index ].thread_entry,                             
      NULL                                                            
    );                                                                
    if ( status )                                                     
 20079b0:	80 a2 20 00 	cmp  %o0, 0                                    
 20079b4:	02 80 00 05 	be  20079c8 <_POSIX_Threads_Initialize_user_threads_body+0x78>
 20079b8:	94 10 00 08 	mov  %o0, %o2                                  
      _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
 20079bc:	90 10 20 02 	mov  2, %o0                                    
 20079c0:	40 00 08 0a 	call  20099e8 <_Internal_error_Occurred>       
 20079c4:	92 10 20 01 	mov  1, %o1                                    
   *                                                                  
   *  Setting the attributes explicitly is critical, since we don't want
   *  to inherit the idle tasks attributes.                           
   */                                                                 
                                                                      
  for ( index=0 ; index < maximum ; index++ ) {                       
 20079c8:	b8 07 20 01 	inc  %i4                                       
 20079cc:	80 a7 00 1b 	cmp  %i4, %i3                                  
 20079d0:	12 bf ff ea 	bne  2007978 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
 20079d4:	01 00 00 00 	nop                                            
 20079d8:	81 c7 e0 08 	ret                                            
 20079dc:	81 e8 00 00 	restore                                        
                                                                      

0200cc1c <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) {
 200cc1c:	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 ];               
 200cc20:	fa 06 61 5c 	ld  [ %i1 + 0x15c ], %i5                       
                                                                      
  /* ticks is guaranteed to be at least one */                        
  ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
 200cc24:	40 00 03 fd 	call  200dc18 <_Timespec_To_ticks>             
 200cc28:	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);
 200cc2c:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 200cc30:	d2 08 61 2c 	ldub  [ %g1 + 0x12c ], %o1	! 201c92c <rtems_maximum_priority>
 200cc34:	c2 07 60 88 	ld  [ %i5 + 0x88 ], %g1                        
                                                                      
  the_thread->cpu_time_budget = ticks;                                
 200cc38:	d0 26 60 74 	st  %o0, [ %i1 + 0x74 ]                        
 200cc3c:	92 22 40 01 	sub  %o1, %g1, %o1                             
   */                                                                 
  #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 ) {                            
 200cc40:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 200cc44:	80 a0 60 00 	cmp  %g1, 0                                    
 200cc48:	12 80 00 09 	bne  200cc6c <_POSIX_Threads_Sporadic_budget_TSR+0x50><== NEVER TAKEN
 200cc4c:	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 ) {              
 200cc50:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
 200cc54:	80 a0 40 09 	cmp  %g1, %o1                                  
 200cc58:	08 80 00 06 	bleu  200cc70 <_POSIX_Threads_Sporadic_budget_TSR+0x54>
 200cc5c:	90 07 60 90 	add  %i5, 0x90, %o0                            
      _Thread_Change_priority( the_thread, new_priority, true );      
 200cc60:	90 10 00 19 	mov  %i1, %o0                                  
 200cc64:	7f ff f3 c9 	call  2009b88 <_Thread_Change_priority>        
 200cc68:	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 );
 200cc6c:	90 07 60 90 	add  %i5, 0x90, %o0                            
 200cc70:	40 00 03 ea 	call  200dc18 <_Timespec_To_ticks>             
 200cc74:	31 00 80 75 	sethi  %hi(0x201d400), %i0                     
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 200cc78:	b0 16 22 6c 	or  %i0, 0x26c, %i0	! 201d66c <_Watchdog_Ticks_chain>
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 200cc7c:	d0 27 60 b4 	st  %o0, [ %i5 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 200cc80:	7f ff f8 19 	call  200ace4 <_Watchdog_Insert>               
 200cc84:	93 ef 60 a8 	restore  %i5, 0xa8, %o1                        
                                                                      

0200cc88 <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ];
 200cc88:	c4 02 21 5c 	ld  [ %o0 + 0x15c ], %g2                       
                                                                      
  /*                                                                  
   *  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 */
 200cc8c:	86 10 3f ff 	mov  -1, %g3                                   
 200cc90:	c4 00 a0 8c 	ld  [ %g2 + 0x8c ], %g2                        
 200cc94:	c6 22 20 74 	st  %g3, [ %o0 + 0x74 ]                        
 200cc98:	07 00 80 72 	sethi  %hi(0x201c800), %g3                     
 200cc9c:	d2 08 e1 2c 	ldub  [ %g3 + 0x12c ], %o1	! 201c92c <rtems_maximum_priority>
 200cca0:	92 22 40 02 	sub  %o1, %g2, %o1                             
   */                                                                 
  #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 ) {                            
 200cca4:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
 200cca8:	80 a0 a0 00 	cmp  %g2, 0                                    
 200ccac:	12 80 00 09 	bne  200ccd0 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
 200ccb0:	d2 22 20 18 	st  %o1, [ %o0 + 0x18 ]                        
    /*                                                                
     *  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 ) {              
 200ccb4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
 200ccb8:	80 a0 40 09 	cmp  %g1, %o1                                  
 200ccbc:	1a 80 00 05 	bcc  200ccd0 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
 200ccc0:	94 10 20 01 	mov  1, %o2                                    
      _Thread_Change_priority( the_thread, new_priority, true );      
 200ccc4:	82 13 c0 00 	mov  %o7, %g1                                  
 200ccc8:	7f ff f3 b0 	call  2009b88 <_Thread_Change_priority>        
 200cccc:	9e 10 40 00 	mov  %g1, %o7                                  
 200ccd0:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

02007408 <_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) {
 2007408:	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;                              
 200740c:	c2 06 60 68 	ld  [ %i1 + 0x68 ], %g1                        
 2007410:	82 00 60 01 	inc  %g1                                       
 2007414:	c2 26 60 68 	st  %g1, [ %i1 + 0x68 ]                        
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
 2007418:	c2 06 60 54 	ld  [ %i1 + 0x54 ], %g1                        
 200741c:	80 a0 60 00 	cmp  %g1, 0                                    
 2007420:	32 80 00 07 	bne,a   200743c <_POSIX_Timer_TSR+0x34>        
 2007424:	d2 06 60 64 	ld  [ %i1 + 0x64 ], %o1                        
 2007428:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
 200742c:	80 a0 60 00 	cmp  %g1, 0                                    
 2007430:	02 80 00 1f 	be  20074ac <_POSIX_Timer_TSR+0xa4>            <== NEVER TAKEN
 2007434:	82 10 20 04 	mov  4, %g1                                    
       ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {            
    activated = _POSIX_Timer_Insert_helper(                           
 2007438:	d2 06 60 64 	ld  [ %i1 + 0x64 ], %o1                        
 200743c:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
 2007440:	90 06 60 10 	add  %i1, 0x10, %o0                            
 2007444:	17 00 80 1d 	sethi  %hi(0x2007400), %o3                     
 2007448:	98 10 00 19 	mov  %i1, %o4                                  
 200744c:	40 00 18 3b 	call  200d538 <_POSIX_Timer_Insert_helper>     
 2007450:	96 12 e0 08 	or  %o3, 8, %o3                                
      ptimer->ticks,                                                  
      ptimer->Object.id,                                              
      _POSIX_Timer_TSR,                                               
      ptimer                                                          
    );                                                                
    if ( !activated )                                                 
 2007454:	80 8a 20 ff 	btst  0xff, %o0                                
 2007458:	02 80 00 1a 	be  20074c0 <_POSIX_Timer_TSR+0xb8>            <== NEVER TAKEN
 200745c:	90 07 bf f8 	add  %fp, -8, %o0                              
 2007460:	13 00 80 77 	sethi  %hi(0x201dc00), %o1                     
 2007464:	40 00 05 ed 	call  2008c18 <_TOD_Get_with_nanoseconds>      
 2007468:	92 12 63 68 	or  %o1, 0x368, %o1	! 201df68 <_TOD>           
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
}                                                                     
 200746c:	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);           
 2007470:	94 10 20 00 	clr  %o2                                       
 2007474:	90 10 00 1c 	mov  %i4, %o0                                  
 2007478:	92 10 00 1d 	mov  %i5, %o1                                  
 200747c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2007480:	40 00 48 66 	call  2019618 <__divdi3>                       
 2007484:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 2007488:	90 10 00 1c 	mov  %i4, %o0                                  
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
 200748c:	d2 26 60 6c 	st  %o1, [ %i1 + 0x6c ]                        
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 2007490:	94 10 20 00 	clr  %o2                                       
 2007494:	92 10 00 1d 	mov  %i5, %o1                                  
 2007498:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 200749c:	40 00 49 4a 	call  20199c4 <__moddi3>                       
 20074a0:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
                                                                      
    /* 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;                     
 20074a4:	82 10 20 03 	mov  3, %g1                                    
 20074a8:	d2 26 60 70 	st  %o1, [ %i1 + 0x70 ]                        
  /*                                                                  
   * 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 ) ) {
 20074ac:	d0 06 60 38 	ld  [ %i1 + 0x38 ], %o0                        
 20074b0:	d2 06 60 44 	ld  [ %i1 + 0x44 ], %o1                        
 20074b4:	40 00 17 10 	call  200d0f4 <pthread_kill>                   
 20074b8:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
  }                                                                   
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
 20074bc:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
 20074c0:	81 c7 e0 08 	ret                                            
 20074c4:	81 e8 00 00 	restore                                        
                                                                      

0200ef44 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) {
 200ef44:	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,   
 200ef48:	98 10 20 01 	mov  1, %o4                                    
 200ef4c:	90 10 00 18 	mov  %i0, %o0                                  
 200ef50:	92 10 00 19 	mov  %i1, %o1                                  
 200ef54:	94 07 bf cc 	add  %fp, -52, %o2                             
 200ef58:	40 00 00 2e 	call  200f010 <_POSIX_signals_Clear_signals>   
 200ef5c:	96 10 00 1a 	mov  %i2, %o3                                  
 200ef60:	80 8a 20 ff 	btst  0xff, %o0                                
 200ef64:	02 80 00 28 	be  200f004 <_POSIX_signals_Check_signal+0xc0> 
 200ef68:	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 )        
 200ef6c:	85 2e 60 02 	sll  %i1, 2, %g2                               
 200ef70:	35 00 80 76 	sethi  %hi(0x201d800), %i2                     
 200ef74:	b7 2e 60 04 	sll  %i1, 4, %i3                               
 200ef78:	b4 16 a3 50 	or  %i2, 0x350, %i2                            
 200ef7c:	b6 26 c0 02 	sub  %i3, %g2, %i3                             
 200ef80:	84 06 80 1b 	add  %i2, %i3, %g2                             
 200ef84:	fa 00 a0 08 	ld  [ %g2 + 8 ], %i5                           
 200ef88:	80 a7 60 01 	cmp  %i5, 1                                    
 200ef8c:	02 80 00 1e 	be  200f004 <_POSIX_signals_Check_signal+0xc0> <== NEVER TAKEN
 200ef90:	90 07 bf d8 	add  %fp, -40, %o0                             
    return false;                                                     
                                                                      
  /*                                                                  
   *  Block the signals requested in sa_mask                          
   */                                                                 
  saved_signals_blocked = api->signals_blocked;                       
 200ef94:	f8 06 20 d0 	ld  [ %i0 + 0xd0 ], %i4                        
  api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;    
 200ef98:	c2 00 a0 04 	ld  [ %g2 + 4 ], %g1                           
 200ef9c:	82 10 40 1c 	or  %g1, %i4, %g1                              
 200efa0:	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,  
 200efa4:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 200efa8:	d2 00 63 00 	ld  [ %g1 + 0x300 ], %o1	! 201db00 <_Per_CPU_Information+0x10>
 200efac:	94 10 20 28 	mov  0x28, %o2                                 
 200efb0:	40 00 04 00 	call  200ffb0 <memcpy>                         
 200efb4:	92 02 60 20 	add  %o1, 0x20, %o1                            
          sizeof( Thread_Wait_information ));                         
                                                                      
  /*                                                                  
   *  Here, the signal handler function executes                      
   */                                                                 
  switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {               
 200efb8:	c2 06 80 1b 	ld  [ %i2 + %i3 ], %g1                         
 200efbc:	80 a0 60 02 	cmp  %g1, 2                                    
 200efc0:	12 80 00 07 	bne  200efdc <_POSIX_signals_Check_signal+0x98>
 200efc4:	90 10 00 19 	mov  %i1, %o0                                  
    case SA_SIGINFO:                                                  
      (*_POSIX_signals_Vectors[ signo ].sa_sigaction)(                
 200efc8:	92 07 bf cc 	add  %fp, -52, %o1                             
 200efcc:	9f c7 40 00 	call  %i5                                      
 200efd0:	94 10 20 00 	clr  %o2                                       
        signo,                                                        
        &siginfo_struct,                                              
        NULL        /* context is undefined per 1003.1b-1993, p. 66 */
      );                                                              
      break;                                                          
 200efd4:	10 80 00 05 	b  200efe8 <_POSIX_signals_Check_signal+0xa4>  
 200efd8:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
    default:                                                          
      (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );         
 200efdc:	9f c7 40 00 	call  %i5                                      
 200efe0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Restore the blocking information                                
   */                                                                 
  memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,  
 200efe4:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 200efe8:	d0 00 63 00 	ld  [ %g1 + 0x300 ], %o0	! 201db00 <_Per_CPU_Information+0x10>
 200efec:	92 07 bf d8 	add  %fp, -40, %o1                             
 200eff0:	90 02 20 20 	add  %o0, 0x20, %o0                            
 200eff4:	40 00 03 ef 	call  200ffb0 <memcpy>                         
 200eff8:	94 10 20 28 	mov  0x28, %o2                                 
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
                                                                      
  return true;                                                        
 200effc:	82 10 20 01 	mov  1, %g1                                    
          sizeof( Thread_Wait_information ));                         
                                                                      
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
 200f000:	f8 26 20 d0 	st  %i4, [ %i0 + 0xd0 ]                        
                                                                      
  return true;                                                        
}                                                                     
 200f004:	b0 08 60 01 	and  %g1, 1, %i0                               
 200f008:	81 c7 e0 08 	ret                                            
 200f00c:	81 e8 00 00 	restore                                        
                                                                      

0200f5c8 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) {
 200f5c8:	9d e3 bf a0 	save  %sp, -96, %sp                            
 200f5cc:	82 06 3f ff 	add  %i0, -1, %g1                              
 200f5d0:	ba 10 20 01 	mov  1, %i5                                    
  clear_signal = true;                                                
  mask         = signo_to_mask( signo );                              
                                                                      
  ISR_Level  level;                                                   
                                                                      
  _ISR_Disable( level );                                              
 200f5d4:	7f ff cb fc 	call  20025c4 <sparc_disable_interrupts>       
 200f5d8:	bb 2f 40 01 	sll  %i5, %g1, %i5                             
    if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {   
 200f5dc:	05 00 80 76 	sethi  %hi(0x201d800), %g2                     
 200f5e0:	83 2e 20 02 	sll  %i0, 2, %g1                               
 200f5e4:	84 10 a3 50 	or  %g2, 0x350, %g2                            
 200f5e8:	b1 2e 20 04 	sll  %i0, 4, %i0                               
 200f5ec:	82 26 00 01 	sub  %i0, %g1, %g1                             
 200f5f0:	c4 00 80 01 	ld  [ %g2 + %g1 ], %g2                         
 200f5f4:	80 a0 a0 02 	cmp  %g2, 2                                    
 200f5f8:	32 80 00 0c 	bne,a   200f628 <_POSIX_signals_Clear_process_signals+0x60>
 200f5fc:	03 00 80 77 	sethi  %hi(0x201dc00), %g1                     
      if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )     
 200f600:	05 00 80 77 	sethi  %hi(0x201dc00), %g2                     
 200f604:	84 10 a1 48 	or  %g2, 0x148, %g2	! 201dd48 <_POSIX_signals_Siginfo>
 200f608:	86 00 40 02 	add  %g1, %g2, %g3                             
 200f60c:	c2 00 40 02 	ld  [ %g1 + %g2 ], %g1                         
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 200f610:	86 00 e0 04 	add  %g3, 4, %g3                               
 200f614:	80 a0 40 03 	cmp  %g1, %g3                                  
 200f618:	02 80 00 04 	be  200f628 <_POSIX_signals_Clear_process_signals+0x60><== ALWAYS TAKEN
 200f61c:	03 00 80 77 	sethi  %hi(0x201dc00), %g1                     
       clear_signal = false;                                          
    }                                                                 
    if ( clear_signal ) {                                             
      _POSIX_signals_Pending &= ~mask;                                
    }                                                                 
  _ISR_Enable( level );                                               
 200f620:	7f ff cb ed 	call  20025d4 <sparc_enable_interrupts>        
 200f624:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {   
      if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )     
       clear_signal = false;                                          
    }                                                                 
    if ( clear_signal ) {                                             
      _POSIX_signals_Pending &= ~mask;                                
 200f628:	c4 00 61 44 	ld  [ %g1 + 0x144 ], %g2                       
 200f62c:	ba 28 80 1d 	andn  %g2, %i5, %i5                            
 200f630:	10 bf ff fc 	b  200f620 <_POSIX_signals_Clear_process_signals+0x58>
 200f634:	fa 20 61 44 	st  %i5, [ %g1 + 0x144 ]                       
                                                                      

02008200 <_POSIX_signals_Get_lowest>: sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
 2008200:	82 10 20 1b 	mov  0x1b, %g1                                 
 2008204:	84 10 20 01 	mov  1, %g2                                    
#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(                                 
 2008208:	86 00 7f ff 	add  %g1, -1, %g3                              
 200820c:	87 28 80 03 	sll  %g2, %g3, %g3                             
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
    if ( set & signo_to_mask( signo ) ) {                             
 2008210:	80 88 c0 08 	btst  %g3, %o0                                 
 2008214:	12 80 00 11 	bne  2008258 <_POSIX_signals_Get_lowest+0x58>  <== NEVER TAKEN
 2008218:	01 00 00 00 	nop                                            
  sigset_t   set                                                      
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
 200821c:	82 00 60 01 	inc  %g1                                       
 2008220:	80 a0 60 20 	cmp  %g1, 0x20                                 
 2008224:	12 bf ff fa 	bne  200820c <_POSIX_signals_Get_lowest+0xc>   
 2008228:	86 00 7f ff 	add  %g1, -1, %g3                              
 200822c:	82 10 20 01 	mov  1, %g1                                    
 2008230:	84 10 20 01 	mov  1, %g2                                    
#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(                                 
 2008234:	86 00 7f ff 	add  %g1, -1, %g3                              
 2008238:	87 28 80 03 	sll  %g2, %g3, %g3                             
                                                                      
  #if (SIGHUP != 1)                                                   
    #error "Assumption that SIGHUP==1 violated!!"                     
  #endif                                                              
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
    if ( set & signo_to_mask( signo ) ) {                             
 200823c:	80 88 c0 08 	btst  %g3, %o0                                 
 2008240:	12 80 00 06 	bne  2008258 <_POSIX_signals_Get_lowest+0x58>  
 2008244:	01 00 00 00 	nop                                            
   */                                                                 
                                                                      
  #if (SIGHUP != 1)                                                   
    #error "Assumption that SIGHUP==1 violated!!"                     
  #endif                                                              
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
 2008248:	82 00 60 01 	inc  %g1                                       
 200824c:	80 a0 60 1b 	cmp  %g1, 0x1b                                 
 2008250:	12 bf ff fa 	bne  2008238 <_POSIX_signals_Get_lowest+0x38>  <== ALWAYS TAKEN
 2008254:	86 00 7f ff 	add  %g1, -1, %g3                              
   *  a return 0.  This routine will NOT be called unless a signal    
   *  is pending in the set passed in.                                
   */                                                                 
found_it:                                                             
  return signo;                                                       
}                                                                     
 2008258:	81 c3 e0 08 	retl                                           
 200825c:	90 10 00 01 	mov  %g1, %o0                                  
                                                                      

0200c854 <_POSIX_signals_Post_switch_hook>: */ static void _POSIX_signals_Post_switch_hook( Thread_Control *the_thread ) {
 200c854:	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;                   
 200c858:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
  POSIX_API_Control  *api;                                            
  int                 signo;                                          
  ISR_Level           level;                                          
  int                 hold_errno;                                     
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
 200c85c:	fa 06 21 5c 	ld  [ %i0 + 0x15c ], %i5                       
                                                                      
  /*                                                                  
   *  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;                   
 200c860:	c2 00 63 00 	ld  [ %g1 + 0x300 ], %g1                       
                                                                      
  /*                                                                  
   * api may be NULL in case of a thread close in progress            
   */                                                                 
  if ( !api )                                                         
 200c864:	80 a7 60 00 	cmp  %i5, 0                                    
 200c868:	02 80 00 11 	be  200c8ac <_POSIX_signals_Post_switch_hook+0x58><== NEVER TAKEN
 200c86c:	f6 00 60 34 	ld  [ %g1 + 0x34 ], %i3                        
   *  processed at all.  No point in doing this loop otherwise.       
   */                                                                 
  while (1) {                                                         
    _ISR_Disable( level );                                            
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
 200c870:	35 00 80 77 	sethi  %hi(0x201dc00), %i2                     
   *                                                                  
   *  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 );                                            
 200c874:	7f ff d7 54 	call  20025c4 <sparc_disable_interrupts>       
 200c878:	01 00 00 00 	nop                                            
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
 200c87c:	c4 06 a1 44 	ld  [ %i2 + 0x144 ], %g2                       
 200c880:	c2 07 60 d4 	ld  [ %i5 + 0xd4 ], %g1                        
 200c884:	82 10 80 01 	or  %g2, %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 &                                  
 200c888:	c4 07 60 d0 	ld  [ %i5 + 0xd0 ], %g2                        
 200c88c:	80 a8 40 02 	andncc  %g1, %g2, %g0                          
 200c890:	12 80 00 09 	bne  200c8b4 <_POSIX_signals_Post_switch_hook+0x60>
 200c894:	01 00 00 00 	nop                                            
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
 200c898:	7f ff d7 4f 	call  20025d4 <sparc_enable_interrupts>        
 200c89c:	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;                   
 200c8a0:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 200c8a4:	c2 00 63 00 	ld  [ %g1 + 0x300 ], %g1	! 201db00 <_Per_CPU_Information+0x10>
 200c8a8:	f6 20 60 34 	st  %i3, [ %g1 + 0x34 ]                        
 200c8ac:	81 c7 e0 08 	ret                                            
 200c8b0:	81 e8 00 00 	restore                                        
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
 200c8b4:	7f ff d7 48 	call  20025d4 <sparc_enable_interrupts>        
 200c8b8:	b8 10 20 1b 	mov  0x1b, %i4                                 
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
      _POSIX_signals_Check_signal( api, signo, false );               
 200c8bc:	92 10 00 1c 	mov  %i4, %o1                                  
 200c8c0:	94 10 20 00 	clr  %o2                                       
 200c8c4:	40 00 09 a0 	call  200ef44 <_POSIX_signals_Check_signal>    
 200c8c8:	90 10 00 1d 	mov  %i5, %o0                                  
      _POSIX_signals_Check_signal( api, signo, true );                
 200c8cc:	92 10 00 1c 	mov  %i4, %o1                                  
 200c8d0:	90 10 00 1d 	mov  %i5, %o0                                  
 200c8d4:	40 00 09 9c 	call  200ef44 <_POSIX_signals_Check_signal>    
 200c8d8:	94 10 20 01 	mov  1, %o2                                    
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
 200c8dc:	b8 07 20 01 	inc  %i4                                       
 200c8e0:	80 a7 20 20 	cmp  %i4, 0x20                                 
 200c8e4:	12 bf ff f7 	bne  200c8c0 <_POSIX_signals_Post_switch_hook+0x6c>
 200c8e8:	92 10 00 1c 	mov  %i4, %o1                                  
 200c8ec:	b8 10 20 01 	mov  1, %i4                                    
      _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 );               
 200c8f0:	92 10 00 1c 	mov  %i4, %o1                                  
 200c8f4:	94 10 20 00 	clr  %o2                                       
 200c8f8:	40 00 09 93 	call  200ef44 <_POSIX_signals_Check_signal>    
 200c8fc:	90 10 00 1d 	mov  %i5, %o0                                  
      _POSIX_signals_Check_signal( api, signo, true );                
 200c900:	92 10 00 1c 	mov  %i4, %o1                                  
 200c904:	90 10 00 1d 	mov  %i5, %o0                                  
 200c908:	40 00 09 8f 	call  200ef44 <_POSIX_signals_Check_signal>    
 200c90c:	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++ ) {      
 200c910:	b8 07 20 01 	inc  %i4                                       
 200c914:	80 a7 20 1b 	cmp  %i4, 0x1b                                 
 200c918:	12 bf ff f7 	bne  200c8f4 <_POSIX_signals_Post_switch_hook+0xa0>
 200c91c:	92 10 00 1c 	mov  %i4, %o1                                  
 200c920:	30 bf ff d5 	b,a   200c874 <_POSIX_signals_Post_switch_hook+0x20>
                                                                      

0201a2ac <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) {
 201a2ac:	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 ) ) {
 201a2b0:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
 201a2b4:	3b 04 00 20 	sethi  %hi(0x10008000), %i5                    
 201a2b8:	84 06 7f ff 	add  %i1, -1, %g2                              
 201a2bc:	86 10 20 01 	mov  1, %g3                                    
 201a2c0:	b8 08 40 1d 	and  %g1, %i5, %i4                             
{                                                                     
  POSIX_API_Control  *api;                                            
  sigset_t            mask;                                           
  siginfo_t          *the_info = NULL;                                
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
 201a2c4:	c8 06 21 5c 	ld  [ %i0 + 0x15c ], %g4                       
                                                                      
  /*                                                                  
   *  Is the thread is specifically waiting for a signal?             
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
 201a2c8:	80 a7 00 1d 	cmp  %i4, %i5                                  
 201a2cc:	12 80 00 1e 	bne  201a344 <_POSIX_signals_Unblock_thread+0x98>
 201a2d0:	85 28 c0 02 	sll  %g3, %g2, %g2                             
                                                                      
    if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
 201a2d4:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
 201a2d8:	80 88 80 01 	btst  %g2, %g1                                 
 201a2dc:	12 80 00 08 	bne  201a2fc <_POSIX_signals_Unblock_thread+0x50>
 201a2e0:	82 10 20 04 	mov  4, %g1                                    
 201a2e4:	c2 01 20 d0 	ld  [ %g4 + 0xd0 ], %g1                        
 201a2e8:	80 a8 80 01 	andncc  %g2, %g1, %g0                          
 201a2ec:	32 80 00 04 	bne,a   201a2fc <_POSIX_signals_Unblock_thread+0x50>
 201a2f0:	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;                                                       
 201a2f4:	10 80 00 3d 	b  201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
 201a2f8:	b0 10 20 00 	clr  %i0                                       
   */                                                                 
                                                                      
  if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
                                                                      
    if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
      the_thread->Wait.return_code = EINTR;                           
 201a2fc:	c2 26 20 34 	st  %g1, [ %i0 + 0x34 ]                        
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
                                                                      
      if ( !info ) {                                                  
 201a300:	80 a6 a0 00 	cmp  %i2, 0                                    
 201a304:	12 80 00 07 	bne  201a320 <_POSIX_signals_Unblock_thread+0x74>
 201a308:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
        the_info->si_signo = signo;                                   
        the_info->si_code = SI_USER;                                  
 201a30c:	82 10 20 01 	mov  1, %g1                                    
      the_thread->Wait.return_code = EINTR;                           
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
                                                                      
      if ( !info ) {                                                  
        the_info->si_signo = signo;                                   
 201a310:	f2 22 00 00 	st  %i1, [ %o0 ]                               
        the_info->si_code = SI_USER;                                  
 201a314:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
        the_info->si_value.sival_int = 0;                             
 201a318:	10 80 00 05 	b  201a32c <_POSIX_signals_Unblock_thread+0x80>
 201a31c:	c0 22 20 08 	clr  [ %o0 + 8 ]                               
      } else {                                                        
        *the_info = *info;                                            
 201a320:	92 10 00 1a 	mov  %i2, %o1                                  
 201a324:	7f ff d7 23 	call  200ffb0 <memcpy>                         
 201a328:	94 10 20 0c 	mov  0xc, %o2                                  
      }                                                               
                                                                      
      _Thread_queue_Extract_with_proxy( the_thread );                 
 201a32c:	90 10 00 18 	mov  %i0, %o0                                  
 201a330:	7f ff c1 1c 	call  200a7a0 <_Thread_queue_Extract_with_proxy>
 201a334:	b0 10 20 01 	mov  1, %i0                                    
 201a338:	b0 0e 20 01 	and  %i0, 1, %i0                               
 201a33c:	81 c7 e0 08 	ret                                            
 201a340:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Thread is not waiting due to a sigwait.                         
   */                                                                 
  if ( ~api->signals_blocked & mask ) {                               
 201a344:	c8 01 20 d0 	ld  [ %g4 + 0xd0 ], %g4                        
 201a348:	80 a8 80 04 	andncc  %g2, %g4, %g0                          
 201a34c:	02 80 00 26 	be  201a3e4 <_POSIX_signals_Unblock_thread+0x138>
 201a350:	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 ) ) {
 201a354:	80 88 40 02 	btst  %g1, %g2                                 
 201a358:	02 80 00 17 	be  201a3b4 <_POSIX_signals_Unblock_thread+0x108>
 201a35c:	80 a0 60 00 	cmp  %g1, 0                                    
      the_thread->Wait.return_code = EINTR;                           
 201a360:	84 10 20 04 	mov  4, %g2                                    
 201a364:	c4 26 20 34 	st  %g2, [ %i0 + 0x34 ]                        
      /*                                                              
       *  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) )
 201a368:	05 00 00 ef 	sethi  %hi(0x3bc00), %g2                       
 201a36c:	84 10 a2 e0 	or  %g2, 0x2e0, %g2	! 3bee0 <PROM_START+0x3bee0>
 201a370:	80 88 40 02 	btst  %g1, %g2                                 
 201a374:	02 80 00 06 	be  201a38c <_POSIX_signals_Unblock_thread+0xe0>
 201a378:	80 88 60 08 	btst  8, %g1                                   
         _Thread_queue_Extract_with_proxy( the_thread );              
 201a37c:	7f ff c1 09 	call  200a7a0 <_Thread_queue_Extract_with_proxy>
 201a380:	90 10 00 18 	mov  %i0, %o0                                  
    } else if ( the_thread->current_state == STATES_READY ) {         
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
 201a384:	10 80 00 19 	b  201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
 201a388:	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 );              
       else if ( _States_Is_delaying(the_thread->current_state) ) {   
 201a38c:	22 80 00 17 	be,a   201a3e8 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
 201a390:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
          (void) _Watchdog_Remove( &the_thread->Timer );              
 201a394:	7f ff c2 ac 	call  200ae44 <_Watchdog_Remove>               
 201a398:	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 );                  
 201a39c:	90 10 00 18 	mov  %i0, %o0                                  
 201a3a0:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
 201a3a4:	7f ff be 3d 	call  2009c98 <_Thread_Clear_state>            
 201a3a8:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1007fff8 <RAM_END+0xdc7fff8>
    } else if ( the_thread->current_state == STATES_READY ) {         
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
 201a3ac:	10 80 00 0f 	b  201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
 201a3b0:	b0 10 20 00 	clr  %i0                                       
       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 ) {         
 201a3b4:	32 80 00 0d 	bne,a   201a3e8 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
 201a3b8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
 201a3bc:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 201a3c0:	82 10 62 f0 	or  %g1, 0x2f0, %g1	! 201daf0 <_Per_CPU_Information>
 201a3c4:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 201a3c8:	80 a0 a0 00 	cmp  %g2, 0                                    
 201a3cc:	22 80 00 07 	be,a   201a3e8 <_POSIX_signals_Unblock_thread+0x13c>
 201a3d0:	b0 10 20 00 	clr  %i0                                       
 201a3d4:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 201a3d8:	80 a6 00 02 	cmp  %i0, %g2                                  
 201a3dc:	22 80 00 02 	be,a   201a3e4 <_POSIX_signals_Unblock_thread+0x138><== ALWAYS TAKEN
 201a3e0:	c6 28 60 0c 	stb  %g3, [ %g1 + 0xc ]                        
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
 201a3e4:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 201a3e8:	b0 0e 20 01 	and  %i0, 1, %i0                               
 201a3ec:	81 c7 e0 08 	ret                                            
 201a3f0:	81 e8 00 00 	restore                                        
                                                                      

0200a1f0 <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) {
 200a1f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  RBTree_Node *leaf, *target;                                         
  RBTree_Color victim_color;                                          
  RBTree_Direction dir;                                               
                                                                      
  if (!the_node) return;                                              
 200a1f4:	80 a6 60 00 	cmp  %i1, 0                                    
 200a1f8:	02 80 00 69 	be  200a39c <_RBTree_Extract_unprotected+0x1ac>
 200a1fc:	01 00 00 00 	nop                                            
                                                                      
  /* check if min needs to be updated */                              
  if (the_node == the_rbtree->first[RBT_LEFT]) {                      
 200a200:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 200a204:	80 a6 40 01 	cmp  %i1, %g1                                  
 200a208:	32 80 00 07 	bne,a   200a224 <_RBTree_Extract_unprotected+0x34>
 200a20c:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(      
  const RBTree_Node *node                                             
)                                                                     
{                                                                     
  return _RBTree_Next_unprotected( node, RBT_RIGHT );                 
 200a210:	90 10 00 19 	mov  %i1, %o0                                  
 200a214:	40 00 01 31 	call  200a6d8 <_RBTree_Next_unprotected>       
 200a218:	92 10 20 01 	mov  1, %o1                                    
    RBTree_Node *next;                                                
    next = _RBTree_Successor_unprotected(the_node);                   
    the_rbtree->first[RBT_LEFT] = next;                               
 200a21c:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
  }                                                                   
                                                                      
  /* 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]) {                     
 200a220:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 200a224:	80 a6 40 01 	cmp  %i1, %g1                                  
 200a228:	32 80 00 07 	bne,a   200a244 <_RBTree_Extract_unprotected+0x54>
 200a22c:	fa 06 60 04 	ld  [ %i1 + 4 ], %i5                           
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(    
  const RBTree_Node *node                                             
)                                                                     
{                                                                     
  return _RBTree_Next_unprotected( node, RBT_LEFT );                  
 200a230:	90 10 00 19 	mov  %i1, %o0                                  
 200a234:	40 00 01 29 	call  200a6d8 <_RBTree_Next_unprotected>       
 200a238:	92 10 20 00 	clr  %o1                                       
    RBTree_Node *previous;                                            
    previous = _RBTree_Predecessor_unprotected(the_node);             
    the_rbtree->first[RBT_RIGHT] = previous;                          
 200a23c:	d0 26 20 0c 	st  %o0, [ %i0 + 0xc ]                         
   * 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]) {      
 200a240:	fa 06 60 04 	ld  [ %i1 + 4 ], %i5                           
 200a244:	80 a7 60 00 	cmp  %i5, 0                                    
 200a248:	02 80 00 36 	be  200a320 <_RBTree_Extract_unprotected+0x130>
 200a24c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
 200a250:	80 a7 20 00 	cmp  %i4, 0                                    
 200a254:	32 80 00 05 	bne,a   200a268 <_RBTree_Extract_unprotected+0x78>
 200a258:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 200a25c:	10 80 00 35 	b  200a330 <_RBTree_Extract_unprotected+0x140> 
 200a260:	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];
 200a264:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 200a268:	80 a0 60 00 	cmp  %g1, 0                                    
 200a26c:	32 bf ff fe 	bne,a   200a264 <_RBTree_Extract_unprotected+0x74>
 200a270:	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];                                   
 200a274:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           
    if(leaf) {                                                        
 200a278:	80 a7 20 00 	cmp  %i4, 0                                    
 200a27c:	02 80 00 05 	be  200a290 <_RBTree_Extract_unprotected+0xa0> 
 200a280:	01 00 00 00 	nop                                            
      leaf->parent = target->parent;                                  
 200a284:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 200a288:	10 80 00 04 	b  200a298 <_RBTree_Extract_unprotected+0xa8>  
 200a28c:	c2 27 00 00 	st  %g1, [ %i4 ]                               
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(target);                   
 200a290:	7f ff ff 73 	call  200a05c <_RBTree_Extract_validate_unprotected>
 200a294:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
    victim_color = target->color;                                     
    dir = target != target->parent->child[0];                         
 200a298:	c4 07 40 00 	ld  [ %i5 ], %g2                               
      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;                                     
 200a29c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    dir = target != target->parent->child[0];                         
 200a2a0:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
 200a2a4:	86 1f 40 03 	xor  %i5, %g3, %g3                             
 200a2a8:	80 a0 00 03 	cmp  %g0, %g3                                  
 200a2ac:	86 40 20 00 	addx  %g0, 0, %g3                              
    target->parent->child[dir] = leaf;                                
 200a2b0:	87 28 e0 02 	sll  %g3, 2, %g3                               
 200a2b4:	84 00 80 03 	add  %g2, %g3, %g2                             
 200a2b8:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
                                                                      
    /* now replace the_node with target */                            
    dir = the_node != the_node->parent->child[0];                     
 200a2bc:	c4 06 40 00 	ld  [ %i1 ], %g2                               
 200a2c0:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
 200a2c4:	86 1e 40 03 	xor  %i1, %g3, %g3                             
 200a2c8:	80 a0 00 03 	cmp  %g0, %g3                                  
 200a2cc:	86 40 20 00 	addx  %g0, 0, %g3                              
    the_node->parent->child[dir] = target;                            
 200a2d0:	87 28 e0 02 	sll  %g3, 2, %g3                               
 200a2d4:	84 00 80 03 	add  %g2, %g3, %g2                             
 200a2d8:	fa 20 a0 04 	st  %i5, [ %g2 + 4 ]                           
                                                                      
    /* set target's new children to the original node's children */   
    target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];            
 200a2dc:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
 200a2e0:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
    if (the_node->child[RBT_RIGHT])                                   
 200a2e4:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
 200a2e8:	80 a0 a0 00 	cmp  %g2, 0                                    
 200a2ec:	32 80 00 02 	bne,a   200a2f4 <_RBTree_Extract_unprotected+0x104><== ALWAYS TAKEN
 200a2f0:	fa 20 80 00 	st  %i5, [ %g2 ]                               
      the_node->child[RBT_RIGHT]->parent = target;                    
    target->child[RBT_LEFT] = the_node->child[RBT_LEFT];              
 200a2f4:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
 200a2f8:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
    if (the_node->child[RBT_LEFT])                                    
 200a2fc:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
 200a300:	80 a0 a0 00 	cmp  %g2, 0                                    
 200a304:	32 80 00 02 	bne,a   200a30c <_RBTree_Extract_unprotected+0x11c>
 200a308:	fa 20 80 00 	st  %i5, [ %g2 ]                               
    /* 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;                                
 200a30c:	c4 06 40 00 	ld  [ %i1 ], %g2                               
 200a310:	c4 27 40 00 	st  %g2, [ %i5 ]                               
    target->color = the_node->color;                                  
 200a314:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 200a318:	10 80 00 14 	b  200a368 <_RBTree_Extract_unprotected+0x178> 
 200a31c:	c4 27 60 0c 	st  %g2, [ %i5 + 0xc ]                         
     * 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 ) {                                                      
 200a320:	80 a7 20 00 	cmp  %i4, 0                                    
 200a324:	32 80 00 04 	bne,a   200a334 <_RBTree_Extract_unprotected+0x144>
 200a328:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 200a32c:	30 80 00 04 	b,a   200a33c <_RBTree_Extract_unprotected+0x14c>
      leaf->parent = the_node->parent;                                
 200a330:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 200a334:	10 80 00 04 	b  200a344 <_RBTree_Extract_unprotected+0x154> 
 200a338:	c2 27 00 00 	st  %g1, [ %i4 ]                               
    } else {                                                          
      /* fix the tree here if the child is a null leaf. */            
      _RBTree_Extract_validate_unprotected(the_node);                 
 200a33c:	7f ff ff 48 	call  200a05c <_RBTree_Extract_validate_unprotected>
 200a340:	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];                     
 200a344:	c4 06 40 00 	ld  [ %i1 ], %g2                               
      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;                                   
 200a348:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
                                                                      
    /* remove the_node from the tree */                               
    dir = the_node != the_node->parent->child[0];                     
 200a34c:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
 200a350:	86 1e 40 03 	xor  %i1, %g3, %g3                             
 200a354:	80 a0 00 03 	cmp  %g0, %g3                                  
 200a358:	86 40 20 00 	addx  %g0, 0, %g3                              
    the_node->parent->child[dir] = leaf;                              
 200a35c:	87 28 e0 02 	sll  %g3, 2, %g3                               
 200a360:	84 00 80 03 	add  %g2, %g3, %g2                             
 200a364:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
  /* 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 */             
 200a368:	80 a0 60 00 	cmp  %g1, 0                                    
 200a36c:	32 80 00 06 	bne,a   200a384 <_RBTree_Extract_unprotected+0x194>
 200a370:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
    if (leaf) {                                                       
 200a374:	80 a7 20 00 	cmp  %i4, 0                                    
 200a378:	32 80 00 02 	bne,a   200a380 <_RBTree_Extract_unprotected+0x190>
 200a37c:	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;          
 200a380:	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;
 200a384:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
 200a388:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
 200a38c:	80 a0 60 00 	cmp  %g1, 0                                    
 200a390:	02 80 00 03 	be  200a39c <_RBTree_Extract_unprotected+0x1ac>
 200a394:	c0 26 40 00 	clr  [ %i1 ]                                   
 200a398:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
 200a39c:	81 c7 e0 08 	ret                                            
 200a3a0:	81 e8 00 00 	restore                                        
                                                                      

0200b3e4 <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) {
 200b3e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t      count;                                                  
  RBTree_Node *next;                                                  
                                                                      
  /* TODO: Error message? */                                          
  if (!the_rbtree) return;                                            
 200b3e8:	80 a6 20 00 	cmp  %i0, 0                                    
 200b3ec:	02 80 00 10 	be  200b42c <_RBTree_Initialize+0x48>          <== NEVER TAKEN
 200b3f0:	01 00 00 00 	nop                                            
    RBTree_Control          *the_rbtree,                              
    RBTree_Compare_function  compare_function,                        
    bool                     is_unique                                
    )                                                                 
{                                                                     
  the_rbtree->permanent_null   = NULL;                                
 200b3f4:	c0 26 00 00 	clr  [ %i0 ]                                   
  the_rbtree->root             = NULL;                                
 200b3f8:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
  the_rbtree->first[0]         = NULL;                                
 200b3fc:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
  the_rbtree->first[1]         = NULL;                                
 200b400:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  the_rbtree->compare_function = compare_function;                    
 200b404:	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-- ) {                                                 
 200b408:	10 80 00 06 	b  200b420 <_RBTree_Initialize+0x3c>           
 200b40c:	fa 2e 20 14 	stb  %i5, [ %i0 + 0x14 ]                       
    _RBTree_Insert_unprotected(the_rbtree, next);                     
 200b410:	90 10 00 18 	mov  %i0, %o0                                  
 200b414:	7f ff ff 2e 	call  200b0cc <_RBTree_Insert_unprotected>     
 200b418:	b4 06 80 1c 	add  %i2, %i4, %i2                             
 200b41c:	b6 06 ff ff 	add  %i3, -1, %i3                              
  /* could do sanity checks here */                                   
  _RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);  
                                                                      
  count = number_nodes;                                               
  next  = starting_address;                                           
  while ( count-- ) {                                                 
 200b420:	80 a6 e0 00 	cmp  %i3, 0                                    
 200b424:	12 bf ff fb 	bne  200b410 <_RBTree_Initialize+0x2c>         
 200b428:	92 10 00 1a 	mov  %i2, %o1                                  
 200b42c:	81 c7 e0 08 	ret                                            
 200b430:	81 e8 00 00 	restore                                        
                                                                      

0200a444 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) {
 200a444:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if(!the_node) return (RBTree_Node*)-1;                              
 200a448:	80 a6 60 00 	cmp  %i1, 0                                    
 200a44c:	02 80 00 7c 	be  200a63c <_RBTree_Insert_unprotected+0x1f8> 
 200a450:	ba 10 00 18 	mov  %i0, %i5                                  
                                                                      
  RBTree_Node *iter_node = the_rbtree->root;                          
 200a454:	f0 06 20 04 	ld  [ %i0 + 4 ], %i0                           
  int compare_result;                                                 
                                                                      
  if (!iter_node) { /* special case: first node inserted */           
 200a458:	b6 96 20 00 	orcc  %i0, 0, %i3                              
 200a45c:	32 80 00 0c 	bne,a   200a48c <_RBTree_Insert_unprotected+0x48>
 200a460:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
    the_node->color = RBT_BLACK;                                      
 200a464:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
    the_rbtree->root = the_node;                                      
 200a468:	f2 27 60 04 	st  %i1, [ %i5 + 4 ]                           
    the_rbtree->first[0] = the_rbtree->first[1] = the_node;           
 200a46c:	f2 27 60 0c 	st  %i1, [ %i5 + 0xc ]                         
 200a470:	f2 27 60 08 	st  %i1, [ %i5 + 8 ]                           
    the_node->parent = (RBTree_Node *) the_rbtree;                    
 200a474:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
 200a478:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
 200a47c:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
 200a480:	81 c7 e0 08 	ret                                            
 200a484:	81 e8 00 00 	restore                                        
  } 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);
 200a488:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200a48c:	90 10 00 19 	mov  %i1, %o0                                  
 200a490:	9f c0 40 00 	call  %g1                                      
 200a494:	92 10 00 18 	mov  %i0, %o1                                  
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
 200a498:	c2 0f 60 14 	ldub  [ %i5 + 0x14 ], %g1                      
 200a49c:	80 a0 60 00 	cmp  %g1, 0                                    
 200a4a0:	02 80 00 05 	be  200a4b4 <_RBTree_Insert_unprotected+0x70>  
 200a4a4:	b8 38 00 08 	xnor  %g0, %o0, %i4                            
 200a4a8:	80 a2 20 00 	cmp  %o0, 0                                    
 200a4ac:	02 80 00 65 	be  200a640 <_RBTree_Insert_unprotected+0x1fc> 
 200a4b0:	01 00 00 00 	nop                                            
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
 200a4b4:	b9 37 20 1f 	srl  %i4, 0x1f, %i4                            
      if (!iter_node->child[dir]) {                                   
 200a4b8:	83 2f 20 02 	sll  %i4, 2, %g1                               
 200a4bc:	82 06 00 01 	add  %i0, %g1, %g1                             
 200a4c0:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
 200a4c4:	80 a6 20 00 	cmp  %i0, 0                                    
 200a4c8:	32 bf ff f0 	bne,a   200a488 <_RBTree_Insert_unprotected+0x44>
 200a4cc:	b6 10 00 18 	mov  %i0, %i3                                  
        the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
 200a4d0:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
 200a4d4:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
        the_node->color = RBT_RED;                                    
 200a4d8:	84 10 20 01 	mov  1, %g2                                    
        iter_node->child[dir] = the_node;                             
 200a4dc:	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;                                    
 200a4e0:	c4 26 60 0c 	st  %g2, [ %i1 + 0xc ]                         
        iter_node->child[dir] = the_node;                             
        the_node->parent = iter_node;                                 
 200a4e4:	f6 26 40 00 	st  %i3, [ %i1 ]                               
        /* update min/max */                                          
        compare_result = the_rbtree->compare_function(                
 200a4e8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(                      
  const RBTree_Control *the_rbtree,                                   
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return the_rbtree->first[dir];                                      
 200a4ec:	b6 07 20 02 	add  %i4, 2, %i3                               
 200a4f0:	85 2e e0 02 	sll  %i3, 2, %g2                               
 200a4f4:	d2 07 40 02 	ld  [ %i5 + %g2 ], %o1                         
 200a4f8:	9f c0 40 00 	call  %g1                                      
 200a4fc:	90 10 00 19 	mov  %i1, %o0                                  
            the_node,                                                 
            _RBTree_First(the_rbtree, dir)                            
        );                                                            
        if ( (!dir && _RBTree_Is_lesser(compare_result)) ||           
 200a500:	80 a7 20 00 	cmp  %i4, 0                                    
 200a504:	12 80 00 06 	bne  200a51c <_RBTree_Insert_unprotected+0xd8> 
 200a508:	80 a2 20 00 	cmp  %o0, 0                                    
 200a50c:	36 80 00 3c 	bge,a   200a5fc <_RBTree_Insert_unprotected+0x1b8>
 200a510:	d0 06 40 00 	ld  [ %i1 ], %o0                               
              (dir && _RBTree_Is_greater(compare_result)) ) {         
          the_rbtree->first[dir] = the_node;                          
 200a514:	10 80 00 04 	b  200a524 <_RBTree_Insert_unprotected+0xe0>   
 200a518:	b7 2e e0 02 	sll  %i3, 2, %i3                               
        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)) ) {         
 200a51c:	04 80 00 37 	ble  200a5f8 <_RBTree_Insert_unprotected+0x1b4>
 200a520:	b7 2e e0 02 	sll  %i3, 2, %i3                               
          the_rbtree->first[dir] = the_node;                          
 200a524:	10 80 00 35 	b  200a5f8 <_RBTree_Insert_unprotected+0x1b4>  
 200a528:	f2 27 40 1b 	st  %i1, [ %i5 + %i3 ]                         
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if(!the_node) return NULL;                                          
  if(!(the_node->parent)) return NULL;                                
  if(!(the_node->parent->parent)) return NULL;                        
 200a52c:	02 80 00 13 	be  200a578 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
 200a530:	82 10 20 00 	clr  %g1                                       
  if(!(the_node->parent->parent->parent)) return NULL;                
 200a534:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 200a538:	80 a0 60 00 	cmp  %g1, 0                                    
 200a53c:	02 80 00 0f 	be  200a578 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
 200a540:	82 10 20 00 	clr  %g1                                       
{                                                                     
  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])                   
 200a544:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 200a548:	80 a2 00 01 	cmp  %o0, %g1                                  
 200a54c:	22 80 00 02 	be,a   200a554 <_RBTree_Insert_unprotected+0x110>
 200a550:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
 200a554:	80 a0 60 00 	cmp  %g1, 0                                    
 200a558:	02 80 00 09 	be  200a57c <_RBTree_Insert_unprotected+0x138> 
 200a55c:	84 10 20 00 	clr  %g2                                       
 200a560:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 200a564:	80 a0 a0 01 	cmp  %g2, 1                                    
 200a568:	32 80 00 05 	bne,a   200a57c <_RBTree_Insert_unprotected+0x138>
 200a56c:	84 10 20 00 	clr  %g2                                       
 200a570:	10 80 00 03 	b  200a57c <_RBTree_Insert_unprotected+0x138>  
 200a574:	84 10 20 01 	mov  1, %g2                                    
 200a578:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
  while (_RBTree_Is_red(_RBTree_Parent(the_node))) {                  
    u = _RBTree_Parent_sibling(the_node);                             
    g = the_node->parent->parent;                                     
                                                                      
    /* if uncle is red, repaint uncle/parent black and grandparent red */
    if(_RBTree_Is_red(u)) {                                           
 200a57c:	80 a0 a0 00 	cmp  %g2, 0                                    
 200a580:	22 80 00 08 	be,a   200a5a0 <_RBTree_Insert_unprotected+0x15c>
 200a584:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
      the_node->parent->color = RBT_BLACK;                            
 200a588:	c0 22 20 0c 	clr  [ %o0 + 0xc ]                             
      u->color = RBT_BLACK;                                           
 200a58c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
      g->color = RBT_RED;                                             
 200a590:	b2 10 00 1d 	mov  %i5, %i1                                  
 200a594:	82 10 20 01 	mov  1, %g1                                    
 200a598:	10 80 00 18 	b  200a5f8 <_RBTree_Insert_unprotected+0x1b4>  
 200a59c:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
      the_node = g;                                                   
    } else { /* if uncle is black */                                  
      RBTree_Direction dir = the_node != the_node->parent->child[0];  
      RBTree_Direction pdir = the_node->parent != g->child[0];        
 200a5a0:	82 1a 00 01 	xor  %o0, %g1, %g1                             
 200a5a4:	80 a0 00 01 	cmp  %g0, %g1                                  
      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];  
 200a5a8:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
      RBTree_Direction pdir = the_node->parent != g->child[0];        
 200a5ac:	b8 40 20 00 	addx  %g0, 0, %i4                              
      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];  
 200a5b0:	82 1e 40 01 	xor  %i1, %g1, %g1                             
 200a5b4:	80 a0 00 01 	cmp  %g0, %g1                                  
 200a5b8:	82 40 20 00 	addx  %g0, 0, %g1                              
      RBTree_Direction pdir = the_node->parent != g->child[0];        
                                                                      
      /* ensure node is on the same branch direction as parent */     
      if (dir != pdir) {                                              
 200a5bc:	80 a0 40 1c 	cmp  %g1, %i4                                  
 200a5c0:	22 80 00 08 	be,a   200a5e0 <_RBTree_Insert_unprotected+0x19c>
 200a5c4:	c2 06 40 00 	ld  [ %i1 ], %g1                               
        _RBTree_Rotate(the_node->parent, pdir);                       
 200a5c8:	7f ff ff 80 	call  200a3c8 <_RBTree_Rotate>                 
 200a5cc:	92 10 00 1c 	mov  %i4, %o1                                  
        the_node = the_node->child[pdir];                             
 200a5d0:	83 2f 20 02 	sll  %i4, 2, %g1                               
 200a5d4:	b2 06 40 01 	add  %i1, %g1, %i1                             
 200a5d8:	f2 06 60 04 	ld  [ %i1 + 4 ], %i1                           
      }                                                               
      the_node->parent->color = RBT_BLACK;                            
 200a5dc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
      g->color = RBT_RED;                                             
 200a5e0:	92 10 20 01 	mov  1, %o1                                    
      /* ensure node is on the same branch direction as parent */     
      if (dir != pdir) {                                              
        _RBTree_Rotate(the_node->parent, pdir);                       
        the_node = the_node->child[pdir];                             
      }                                                               
      the_node->parent->color = RBT_BLACK;                            
 200a5e4:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
      g->color = RBT_RED;                                             
 200a5e8:	d2 27 60 0c 	st  %o1, [ %i5 + 0xc ]                         
                                                                      
      /* now rotate grandparent in the other branch direction (toward uncle) */
      _RBTree_Rotate(g, (1-pdir));                                    
 200a5ec:	90 10 00 1d 	mov  %i5, %o0                                  
 200a5f0:	7f ff ff 76 	call  200a3c8 <_RBTree_Rotate>                 
 200a5f4:	92 22 40 1c 	sub  %o1, %i4, %o1                             
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(                     
  const RBTree_Node *the_node                                         
)                                                                     
{                                                                     
  if (!the_node->parent->parent) return NULL;                         
 200a5f8:	d0 06 40 00 	ld  [ %i1 ], %o0                               
 200a5fc:	fa 02 00 00 	ld  [ %o0 ], %i5                               
 200a600:	80 a7 60 00 	cmp  %i5, 0                                    
 200a604:	22 80 00 06 	be,a   200a61c <_RBTree_Insert_unprotected+0x1d8>
 200a608:	82 10 20 00 	clr  %g1                                       
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(                             
    const RBTree_Node *the_node                                       
    )                                                                 
{                                                                     
  return (the_node && the_node->color == RBT_RED);                    
 200a60c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 200a610:	82 18 60 01 	xor  %g1, 1, %g1                               
 200a614:	80 a0 00 01 	cmp  %g0, %g1                                  
 200a618:	82 60 3f ff 	subx  %g0, -1, %g1                             
  RBTree_Node *u,*g;                                                  
                                                                      
  /* note: the insert root case is handled already */                 
  /* if the parent is black, nothing needs to be done                 
   * otherwise may need to loop a few times */                        
  while (_RBTree_Is_red(_RBTree_Parent(the_node))) {                  
 200a61c:	80 a0 60 00 	cmp  %g1, 0                                    
 200a620:	12 bf ff c3 	bne  200a52c <_RBTree_Insert_unprotected+0xe8> 
 200a624:	80 a7 60 00 	cmp  %i5, 0                                    
                                                                      
      /* now rotate grandparent in the other branch direction (toward uncle) */
      _RBTree_Rotate(g, (1-pdir));                                    
    }                                                                 
  }                                                                   
  if(!the_node->parent->parent) the_node->color = RBT_BLACK;          
 200a628:	12 80 00 06 	bne  200a640 <_RBTree_Insert_unprotected+0x1fc>
 200a62c:	01 00 00 00 	nop                                            
 200a630:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
 200a634:	81 c7 e0 08 	ret                                            
 200a638:	81 e8 00 00 	restore                                        
RBTree_Node *_RBTree_Insert_unprotected(                              
    RBTree_Control *the_rbtree,                                       
    RBTree_Node *the_node                                             
    )                                                                 
{                                                                     
  if(!the_node) return (RBTree_Node*)-1;                              
 200a63c:	b0 10 3f ff 	mov  -1, %i0                                   
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
}                                                                     
 200a640:	81 c7 e0 08 	ret                                            
 200a644:	81 e8 00 00 	restore                                        
                                                                      

0200a678 <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) {
 200a678:	9d e3 bf a0 	save  %sp, -96, %sp                            
  RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );       
  const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );      
  bool stop = false;                                                  
 200a67c:	b8 10 20 00 	clr  %i4                                       
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(     
  RBTree_Direction the_dir                                            
)                                                                     
{                                                                     
  return (RBTree_Direction) !((int) the_dir);                         
 200a680:	80 a0 00 19 	cmp  %g0, %i1                                  
 200a684:	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];                                      
 200a688:	82 00 60 02 	add  %g1, 2, %g1                               
 200a68c:	83 28 60 02 	sll  %g1, 2, %g1                               
                                                                      
  while ( !stop && current != NULL ) {                                
 200a690:	10 80 00 0a 	b  200a6b8 <_RBTree_Iterate_unprotected+0x40>  
 200a694:	fa 06 00 01 	ld  [ %i0 + %g1 ], %i5                         
    stop = (*visitor)( current, dir, visitor_arg );                   
 200a698:	92 10 00 19 	mov  %i1, %o1                                  
 200a69c:	9f c6 80 00 	call  %i2                                      
 200a6a0:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    current = _RBTree_Next_unprotected( current, dir );               
 200a6a4:	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 );                   
 200a6a8:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    current = _RBTree_Next_unprotected( current, dir );               
 200a6ac:	40 00 00 0b 	call  200a6d8 <_RBTree_Next_unprotected>       
 200a6b0:	90 10 00 1d 	mov  %i5, %o0                                  
 200a6b4:	ba 10 00 08 	mov  %o0, %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 ) {                                
 200a6b8:	80 a7 60 00 	cmp  %i5, 0                                    
 200a6bc:	02 80 00 05 	be  200a6d0 <_RBTree_Iterate_unprotected+0x58> 
 200a6c0:	b8 1f 20 01 	xor  %i4, 1, %i4                               
 200a6c4:	80 8f 20 ff 	btst  0xff, %i4                                
 200a6c8:	12 bf ff f4 	bne  200a698 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
 200a6cc:	90 10 00 1d 	mov  %i5, %o0                                  
 200a6d0:	81 c7 e0 08 	ret                                            
 200a6d4:	81 e8 00 00 	restore                                        
                                                                      

02009fe0 <_RBTree_Rotate>: RBTree_Node *the_node, RBTree_Direction dir ) { RBTree_Node *c; if (the_node == NULL) return;
 2009fe0:	80 a2 20 00 	cmp  %o0, 0                                    
 2009fe4:	02 80 00 1c 	be  200a054 <_RBTree_Rotate+0x74>              <== NEVER TAKEN
 2009fe8:	80 a0 00 09 	cmp  %g0, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(     
  RBTree_Direction the_dir                                            
)                                                                     
{                                                                     
  return (RBTree_Direction) !((int) the_dir);                         
 2009fec:	86 60 3f ff 	subx  %g0, -1, %g3                             
    RBTree_Direction dir                                              
    )                                                                 
{                                                                     
  RBTree_Node *c;                                                     
  if (the_node == NULL) return;                                       
  if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
 2009ff0:	87 28 e0 02 	sll  %g3, 2, %g3                               
 2009ff4:	86 02 00 03 	add  %o0, %g3, %g3                             
 2009ff8:	c2 00 e0 04 	ld  [ %g3 + 4 ], %g1                           
 2009ffc:	80 a0 60 00 	cmp  %g1, 0                                    
 200a000:	02 80 00 15 	be  200a054 <_RBTree_Rotate+0x74>              <== NEVER TAKEN
 200a004:	93 2a 60 02 	sll  %o1, 2, %o1                               
                                                                      
  c = the_node->child[_RBTree_Opposite_direction(dir)];               
  the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];   
 200a008:	84 00 40 09 	add  %g1, %o1, %g2                             
 200a00c:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
 200a010:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
 200a014:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
 200a018:	80 a0 a0 00 	cmp  %g2, 0                                    
 200a01c:	32 80 00 02 	bne,a   200a024 <_RBTree_Rotate+0x44>          
 200a020:	d0 20 80 00 	st  %o0, [ %g2 ]                               
    c->child[dir]->parent = the_node;                                 
                                                                      
  c->child[dir] = the_node;                                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
 200a024:	c4 02 00 00 	ld  [ %o0 ], %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;                                           
 200a028:	92 00 40 09 	add  %g1, %o1, %o1                             
 200a02c:	d0 22 60 04 	st  %o0, [ %o1 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
 200a030:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
                                                                      
  c->parent = the_node->parent;                                       
 200a034:	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;
 200a038:	86 1a 00 03 	xor  %o0, %g3, %g3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
 200a03c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  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;
 200a040:	80 a0 00 03 	cmp  %g0, %g3                                  
 200a044:	86 40 20 00 	addx  %g0, 0, %g3                              
 200a048:	87 28 e0 02 	sll  %g3, 2, %g3                               
 200a04c:	86 00 80 03 	add  %g2, %g3, %g3                             
 200a050:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
 200a054:	81 c3 e0 08 	retl                                           
                                                                      

02009f90 <_RBTree_Sibling>: */ RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling( const RBTree_Node *the_node ) { if(!the_node) return NULL;
 2009f90:	80 a2 20 00 	cmp  %o0, 0                                    
 2009f94:	02 80 00 10 	be  2009fd4 <_RBTree_Sibling+0x44>             <== NEVER TAKEN
 2009f98:	82 10 20 00 	clr  %g1                                       
  if(!(the_node->parent)) return NULL;                                
 2009f9c:	c4 02 00 00 	ld  [ %o0 ], %g2                               
 2009fa0:	80 a0 a0 00 	cmp  %g2, 0                                    
 2009fa4:	22 80 00 0d 	be,a   2009fd8 <_RBTree_Sibling+0x48>          <== NEVER TAKEN
 2009fa8:	90 10 00 01 	mov  %g1, %o0                                  <== NOT EXECUTED
  if(!(the_node->parent->parent)) return NULL;                        
 2009fac:	c2 00 80 00 	ld  [ %g2 ], %g1                               
 2009fb0:	80 a0 60 00 	cmp  %g1, 0                                    
 2009fb4:	02 80 00 08 	be  2009fd4 <_RBTree_Sibling+0x44>             
 2009fb8:	82 10 20 00 	clr  %g1                                       
                                                                      
  if(the_node == the_node->parent->child[RBT_LEFT])                   
 2009fbc:	c2 00 a0 04 	ld  [ %g2 + 4 ], %g1                           
 2009fc0:	80 a2 00 01 	cmp  %o0, %g1                                  
 2009fc4:	22 80 00 04 	be,a   2009fd4 <_RBTree_Sibling+0x44>          
 2009fc8:	c2 00 a0 08 	ld  [ %g2 + 8 ], %g1                           
    return the_node->parent->child[RBT_RIGHT];                        
 2009fcc:	81 c3 e0 08 	retl                                           
 2009fd0:	90 10 00 01 	mov  %g1, %o0                                  
  else                                                                
    return the_node->parent->child[RBT_LEFT];                         
}                                                                     
 2009fd4:	90 10 00 01 	mov  %g1, %o0                                  
 2009fd8:	81 c3 e0 08 	retl                                           
                                                                      

02008820 <_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 ) {
 2008820:	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 ];                
 2008824:	fa 06 21 58 	ld  [ %i0 + 0x158 ], %i5                       
  if ( !api )                                                         
 2008828:	80 a7 60 00 	cmp  %i5, 0                                    
 200882c:	02 80 00 1c 	be  200889c <_RTEMS_signal_Post_switch_hook+0x7c><== NEVER TAKEN
 2008830:	01 00 00 00 	nop                                            
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
 2008834:	7f ff eb 45 	call  2003548 <sparc_disable_interrupts>       
 2008838:	01 00 00 00 	nop                                            
    signal_set = asr->signals_posted;                                 
 200883c:	f8 07 60 14 	ld  [ %i5 + 0x14 ], %i4                        
    asr->signals_posted = 0;                                          
 2008840:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  _ISR_Enable( level );                                               
 2008844:	7f ff eb 45 	call  2003558 <sparc_enable_interrupts>        
 2008848:	01 00 00 00 	nop                                            
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
 200884c:	80 a7 20 00 	cmp  %i4, 0                                    
 2008850:	02 80 00 13 	be  200889c <_RTEMS_signal_Post_switch_hook+0x7c>
 2008854:	94 07 bf fc 	add  %fp, -4, %o2                              
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
 2008858:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
 200885c:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
 2008860:	82 00 60 01 	inc  %g1                                       
 2008864:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
 2008868:	37 00 00 3f 	sethi  %hi(0xfc00), %i3                        
 200886c:	40 00 01 03 	call  2008c78 <rtems_task_mode>                
 2008870:	92 16 e3 ff 	or  %i3, 0x3ff, %o1	! ffff <PROM_START+0xffff> 
                                                                      
  (*asr->handler)( signal_set );                                      
 2008874:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2008878:	9f c0 40 00 	call  %g1                                      
 200887c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  asr->nest_level -= 1;                                               
 2008880:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
 2008884:	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;                                               
 2008888:	82 00 7f ff 	add  %g1, -1, %g1                              
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
 200888c:	92 16 e3 ff 	or  %i3, 0x3ff, %o1                            
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
                                                                      
  (*asr->handler)( signal_set );                                      
                                                                      
  asr->nest_level -= 1;                                               
 2008890:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
 2008894:	40 00 00 f9 	call  2008c78 <rtems_task_mode>                
 2008898:	94 07 bf fc 	add  %fp, -4, %o2                              
 200889c:	81 c7 e0 08 	ret                                            
 20088a0:	81 e8 00 00 	restore                                        
                                                                      

02032df4 <_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 ) {
 2032df4:	9d e3 bf 98 	save  %sp, -104, %sp                           
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
 2032df8:	13 00 81 87 	sethi  %hi(0x2061c00), %o1                     
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control        uptime;                                  
  #endif                                                              
    Thread_Control          *owning_thread = the_period->owner;       
 2032dfc:	f6 06 20 40 	ld  [ %i0 + 0x40 ], %i3                        
 2032e00:	90 07 bf f8 	add  %fp, -8, %o0                              
 2032e04:	7f ff 55 55 	call  2008358 <_TOD_Get_with_nanoseconds>      
 2032e08:	92 12 63 90 	or  %o1, 0x390, %o1                            
  /*                                                                  
   *  Determine elapsed wall time since period initiated.             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &uptime );                                       
    _Timestamp_Subtract(                                              
 2032e0c:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
 2032e10:	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) {                         
 2032e14:	09 00 81 89 	sethi  %hi(0x2062400), %g4                     
 2032e18:	ba a0 c0 1d 	subcc  %g3, %i5, %i5                           
 2032e1c:	88 11 21 60 	or  %g4, 0x160, %g4                            
 2032e20:	b8 60 80 1c 	subx  %g2, %i4, %i4                            
 2032e24:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
 2032e28:	fa 01 20 10 	ld  [ %g4 + 0x10 ], %i5                        
  #endif                                                              
                                                                      
  /*                                                                  
   *  Determine cpu usage since period initiated.                     
   */                                                                 
  used = owning_thread->cpu_time_used;                                
 2032e2c:	d8 1e e0 80 	ldd  [ %i3 + 0x80 ], %o4                       
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    if (owning_thread == _Thread_Executing) {                         
 2032e30:	80 a6 c0 1d 	cmp  %i3, %i5                                  
 2032e34:	12 80 00 15 	bne  2032e88 <_Rate_monotonic_Get_status+0x94> 
 2032e38:	82 10 20 01 	mov  1, %g1                                    
 2032e3c:	f8 19 20 20 	ldd  [ %g4 + 0x20 ], %i4                       
 2032e40:	86 a0 c0 1d 	subcc  %g3, %i5, %g3                           
 2032e44:	84 60 80 1c 	subx  %g2, %i4, %g2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
 2032e48:	ba 83 40 03 	addcc  %o5, %g3, %i5                           
 2032e4c:	b8 43 00 02 	addx  %o4, %g2, %i4                            
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 2032e50:	c4 1e 20 48 	ldd  [ %i0 + 0x48 ], %g2                       
                                                                      
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
 2032e54:	80 a0 80 1c 	cmp  %g2, %i4                                  
 2032e58:	34 80 00 0c 	bg,a   2032e88 <_Rate_monotonic_Get_status+0x94><== NEVER TAKEN
 2032e5c:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
 2032e60:	32 80 00 06 	bne,a   2032e78 <_Rate_monotonic_Get_status+0x84>
 2032e64:	86 a7 40 03 	subcc  %i5, %g3, %g3                           
 2032e68:	80 a0 c0 1d 	cmp  %g3, %i5                                  
 2032e6c:	18 80 00 06 	bgu  2032e84 <_Rate_monotonic_Get_status+0x90> 
 2032e70:	86 a7 40 03 	subcc  %i5, %g3, %g3                           
      if (used < the_period->cpu_usage_period_initiated)              
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
 2032e74:	82 10 20 01 	mov  1, %g1                                    
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
 2032e78:	84 67 00 02 	subx  %i4, %g2, %g2                            
 2032e7c:	10 80 00 03 	b  2032e88 <_Rate_monotonic_Get_status+0x94>   
 2032e80:	c4 3e 80 00 	std  %g2, [ %i2 ]                              
      /*                                                              
       *  The cpu usage info was reset while executing.  Can't        
       *  determine a status.                                         
       */                                                             
      if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
        return false;                                                 
 2032e84:	82 10 20 00 	clr  %g1                                       
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
}                                                                     
 2032e88:	b0 08 60 01 	and  %g1, 1, %i0                               
 2032e8c:	81 c7 e0 08 	ret                                            
 2032e90:	81 e8 00 00 	restore                                        
                                                                      

020331fc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) {
 20331fc:	9d e3 bf 98 	save  %sp, -104, %sp                           
 2033200:	11 00 81 8a 	sethi  %hi(0x2062800), %o0                     
 2033204:	92 10 00 18 	mov  %i0, %o1                                  
 2033208:	90 12 23 24 	or  %o0, 0x324, %o0                            
 203320c:	7f ff 56 fa 	call  2008df4 <_Objects_Get>                   
 2033210:	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 ) {                                               
 2033214:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2033218:	80 a0 60 00 	cmp  %g1, 0                                    
 203321c:	12 80 00 24 	bne  20332ac <_Rate_monotonic_Timeout+0xb0>    <== NEVER TAKEN
 2033220:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
 2033224:	d0 02 20 40 	ld  [ %o0 + 0x40 ], %o0                        
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
 2033228:	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);                   
 203322c:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
 2033230:	80 88 80 01 	btst  %g2, %g1                                 
 2033234:	22 80 00 0b 	be,a   2033260 <_Rate_monotonic_Timeout+0x64>  
 2033238:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
 203323c:	c4 02 20 20 	ld  [ %o0 + 0x20 ], %g2                        
 2033240:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 2033244:	80 a0 80 01 	cmp  %g2, %g1                                  
 2033248:	32 80 00 06 	bne,a   2033260 <_Rate_monotonic_Timeout+0x64> 
 203324c:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
 2033250:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
 2033254:	7f ff 59 b2 	call  200991c <_Thread_Clear_state>            
 2033258:	92 12 63 f8 	or  %o1, 0x3f8, %o1	! 1007fff8 <RAM_END+0xdc7fff8>
 203325c:	30 80 00 06 	b,a   2033274 <_Rate_monotonic_Timeout+0x78>   
        _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 ) {
 2033260:	80 a0 60 01 	cmp  %g1, 1                                    
 2033264:	12 80 00 0d 	bne  2033298 <_Rate_monotonic_Timeout+0x9c>    
 2033268:	82 10 20 04 	mov  4, %g1                                    
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;    
 203326c:	82 10 20 03 	mov  3, %g1                                    
 2033270:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
 2033274:	7f ff ff 51 	call  2032fb8 <_Rate_monotonic_Initiate_statistics>
 2033278:	90 10 00 1d 	mov  %i5, %o0                                  
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 203327c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2033280:	11 00 81 88 	sethi  %hi(0x2062000), %o0                     
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 2033284:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2033288:	90 12 20 dc 	or  %o0, 0xdc, %o0                             
 203328c:	7f ff 5d b7 	call  200a968 <_Watchdog_Insert>               
 2033290:	92 07 60 10 	add  %i5, 0x10, %o1                            
 2033294:	30 80 00 02 	b,a   203329c <_Rate_monotonic_Timeout+0xa0>   
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else                                                          
        the_period->state = RATE_MONOTONIC_EXPIRED;                   
 2033298:	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;                  
 203329c:	03 00 81 88 	sethi  %hi(0x2062000), %g1                     
 20332a0:	c4 00 60 40 	ld  [ %g1 + 0x40 ], %g2	! 2062040 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
 20332a4:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
 20332a8:	c4 20 60 40 	st  %g2, [ %g1 + 0x40 ]                        
 20332ac:	81 c7 e0 08 	ret                                            
 20332b0:	81 e8 00 00 	restore                                        
                                                                      

02032e94 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) {
 2032e94:	9d e3 bf 90 	save  %sp, -112, %sp                           
                                                                      
  /*                                                                  
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
 2032e98:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
 2032e9c:	82 00 60 01 	inc  %g1                                       
 2032ea0:	c2 26 20 58 	st  %g1, [ %i0 + 0x58 ]                        
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
 2032ea4:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
 2032ea8:	80 a0 60 04 	cmp  %g1, 4                                    
 2032eac:	12 80 00 05 	bne  2032ec0 <_Rate_monotonic_Update_statistics+0x2c>
 2032eb0:	90 10 00 18 	mov  %i0, %o0                                  
    stats->missed_count++;                                            
 2032eb4:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
 2032eb8:	82 00 60 01 	inc  %g1                                       
 2032ebc:	c2 26 20 5c 	st  %g1, [ %i0 + 0x5c ]                        
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
 2032ec0:	92 07 bf f8 	add  %fp, -8, %o1                              
 2032ec4:	7f ff ff cc 	call  2032df4 <_Rate_monotonic_Get_status>     
 2032ec8:	94 07 bf f0 	add  %fp, -16, %o2                             
    _Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
  if (!valid_status)                                                  
 2032ecc:	80 8a 20 ff 	btst  0xff, %o0                                
 2032ed0:	02 80 00 38 	be  2032fb0 <_Rate_monotonic_Update_statistics+0x11c>
 2032ed4:	c4 1f bf f0 	ldd  [ %fp + -16 ], %g2                        
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
 2032ed8:	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 ) )    
 2032edc:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
 2032ee0:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
 2032ee4:	b4 47 00 02 	addx  %i4, %g2, %i2                            
 2032ee8:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032eec:	14 80 00 09 	bg  2032f10 <_Rate_monotonic_Update_statistics+0x7c>
 2032ef0:	f4 3e 20 70 	std  %i2, [ %i0 + 0x70 ]                       
 2032ef4:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032ef8:	32 80 00 08 	bne,a   2032f18 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
 2032efc:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        <== NOT EXECUTED
 2032f00:	c2 06 20 64 	ld  [ %i0 + 0x64 ], %g1                        
 2032f04:	80 a0 40 03 	cmp  %g1, %g3                                  
 2032f08:	28 80 00 04 	bleu,a   2032f18 <_Rate_monotonic_Update_statistics+0x84>
 2032f0c:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
      stats->min_cpu_time = executed;                                 
 2032f10:	c4 3e 20 60 	std  %g2, [ %i0 + 0x60 ]                       
                                                                      
    if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 
 2032f14:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
 2032f18:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032f1c:	26 80 00 0a 	bl,a   2032f44 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
 2032f20:	c4 3e 20 68 	std  %g2, [ %i0 + 0x68 ]                       <== NOT EXECUTED
 2032f24:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032f28:	32 80 00 08 	bne,a   2032f48 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
 2032f2c:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         <== NOT EXECUTED
 2032f30:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        
 2032f34:	80 a0 40 03 	cmp  %g1, %g3                                  
 2032f38:	3a 80 00 04 	bcc,a   2032f48 <_Rate_monotonic_Update_statistics+0xb4>
 2032f3c:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
      stats->max_cpu_time = executed;                                 
 2032f40:	c4 3e 20 68 	std  %g2, [ %i0 + 0x68 ]                       
                                                                      
  /*                                                                  
   *  Update Wall time                                                
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _Timestamp_Add_to( &stats->total_wall_time, &since_last_period ); 
 2032f44:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
 2032f48:	f8 1e 20 88 	ldd  [ %i0 + 0x88 ], %i4                       
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
 2032f4c:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
 2032f50:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
 2032f54:	b4 47 00 02 	addx  %i4, %g2, %i2                            
 2032f58:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032f5c:	14 80 00 09 	bg  2032f80 <_Rate_monotonic_Update_statistics+0xec>
 2032f60:	f4 3e 20 88 	std  %i2, [ %i0 + 0x88 ]                       
 2032f64:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032f68:	32 80 00 08 	bne,a   2032f88 <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
 2032f6c:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
 2032f70:	c2 06 20 7c 	ld  [ %i0 + 0x7c ], %g1                        
 2032f74:	80 a0 40 03 	cmp  %g1, %g3                                  
 2032f78:	28 80 00 04 	bleu,a   2032f88 <_Rate_monotonic_Update_statistics+0xf4>
 2032f7c:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
      stats->min_wall_time = since_last_period;                       
 2032f80:	c4 3e 20 78 	std  %g2, [ %i0 + 0x78 ]                       
                                                                      
    if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
 2032f84:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
 2032f88:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032f8c:	26 80 00 09 	bl,a   2032fb0 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
 2032f90:	c4 3e 20 80 	std  %g2, [ %i0 + 0x80 ]                       <== NOT EXECUTED
 2032f94:	80 a0 40 02 	cmp  %g1, %g2                                  
 2032f98:	12 80 00 06 	bne  2032fb0 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
 2032f9c:	01 00 00 00 	nop                                            
 2032fa0:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
 2032fa4:	80 a0 40 03 	cmp  %g1, %g3                                  
 2032fa8:	2a 80 00 02 	bcs,a   2032fb0 <_Rate_monotonic_Update_statistics+0x11c>
 2032fac:	c4 3e 20 80 	std  %g2, [ %i0 + 0x80 ]                       
 2032fb0:	81 c7 e0 08 	ret                                            
 2032fb4:	81 e8 00 00 	restore                                        
                                                                      

02009ff8 <_Scheduler_CBS_Allocate>: #include <rtems/score/wkspace.h> void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) {
 2009ff8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *sched;                                                        
  Scheduler_CBS_Per_thread *schinfo;                                  
                                                                      
  sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));      
 2009ffc:	40 00 06 bb 	call  200bae8 <_Workspace_Allocate>            
 200a000:	90 10 20 1c 	mov  0x1c, %o0                                 
  if ( sched ) {                                                      
 200a004:	80 a2 20 00 	cmp  %o0, 0                                    
 200a008:	02 80 00 06 	be  200a020 <_Scheduler_CBS_Allocate+0x28>     <== NEVER TAKEN
 200a00c:	82 10 20 02 	mov  2, %g1                                    
    the_thread->scheduler_info = sched;                               
 200a010:	d0 26 20 88 	st  %o0, [ %i0 + 0x88 ]                        
    schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
    schinfo->edf_per_thread.thread = the_thread;                      
 200a014:	f0 22 00 00 	st  %i0, [ %o0 ]                               
    schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
 200a018:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
    schinfo->cbs_server = NULL;                                       
 200a01c:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
  }                                                                   
                                                                      
  return sched;                                                       
}                                                                     
 200a020:	81 c7 e0 08 	ret                                            
 200a024:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0200b338 <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) {
 200b338:	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;                  
 200b33c:	d2 06 20 ac 	ld  [ %i0 + 0xac ], %o1                        
  if ( the_thread->real_priority != new_priority )                    
 200b340:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 200b344:	80 a0 40 09 	cmp  %g1, %o1                                  
 200b348:	32 80 00 02 	bne,a   200b350 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
 200b34c:	d2 26 20 18 	st  %o1, [ %i0 + 0x18 ]                        
    the_thread->real_priority = new_priority;                         
  if ( the_thread->current_priority != new_priority )                 
 200b350:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 200b354:	80 a0 40 09 	cmp  %g1, %o1                                  
 200b358:	02 80 00 04 	be  200b368 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
 200b35c:	90 10 00 18 	mov  %i0, %o0                                  
    _Thread_Change_priority(the_thread, new_priority, true);          
 200b360:	40 00 01 83 	call  200b96c <_Thread_Change_priority>        
 200b364:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  /* Invoke callback function if any. */                              
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
 200b368:	fa 06 20 88 	ld  [ %i0 + 0x88 ], %i5                        
  if ( sched_info->cbs_server->cbs_budget_overrun ) {                 
 200b36c:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
 200b370:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 200b374:	80 a0 a0 00 	cmp  %g2, 0                                    
 200b378:	02 80 00 09 	be  200b39c <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
 200b37c:	01 00 00 00 	nop                                            
    _Scheduler_CBS_Get_server_id(                                     
 200b380:	d0 00 40 00 	ld  [ %g1 ], %o0                               
 200b384:	7f ff ff d7 	call  200b2e0 <_Scheduler_CBS_Get_server_id>   
 200b388:	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 );          
 200b38c:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
 200b390:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 200b394:	9f c0 40 00 	call  %g1                                      
 200b398:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 200b39c:	81 c7 e0 08 	ret                                            
 200b3a0:	81 e8 00 00 	restore                                        
                                                                      

0200af40 <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) {
 200af40:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int i;                                                     
  Scheduler_CBS_Server *the_server;                                   
                                                                      
  if ( params->budget <= 0 ||                                         
 200af44:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 200af48:	80 a0 60 00 	cmp  %g1, 0                                    
 200af4c:	04 80 00 1d 	ble  200afc0 <_Scheduler_CBS_Create_server+0x80>
 200af50:	01 00 00 00 	nop                                            
 200af54:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 200af58:	80 a0 60 00 	cmp  %g1, 0                                    
 200af5c:	04 80 00 19 	ble  200afc0 <_Scheduler_CBS_Create_server+0x80>
 200af60:	03 00 80 80 	sethi  %hi(0x2020000), %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++ ) {              
 200af64:	c4 00 60 80 	ld  [ %g1 + 0x80 ], %g2	! 2020080 <_Scheduler_CBS_Maximum_servers>
    if ( !_Scheduler_CBS_Server_list[i] )                             
 200af68:	03 00 80 84 	sethi  %hi(0x2021000), %g1                     
 200af6c:	c6 00 62 68 	ld  [ %g1 + 0x268 ], %g3	! 2021268 <_Scheduler_CBS_Server_list>
 200af70:	10 80 00 07 	b  200af8c <_Scheduler_CBS_Create_server+0x4c> 
 200af74:	82 10 20 00 	clr  %g1                                       
 200af78:	c8 00 c0 1c 	ld  [ %g3 + %i4 ], %g4                         
 200af7c:	80 a1 20 00 	cmp  %g4, 0                                    
 200af80:	02 80 00 14 	be  200afd0 <_Scheduler_CBS_Create_server+0x90>
 200af84:	3b 00 80 84 	sethi  %hi(0x2021000), %i5                     
       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++ ) {              
 200af88:	82 00 60 01 	inc  %g1                                       
 200af8c:	80 a0 40 02 	cmp  %g1, %g2                                  
 200af90:	12 bf ff fa 	bne  200af78 <_Scheduler_CBS_Create_server+0x38>
 200af94:	b9 28 60 02 	sll  %g1, 2, %i4                               
    if ( !_Scheduler_CBS_Server_list[i] )                             
      break;                                                          
  }                                                                   
                                                                      
  if ( i == _Scheduler_CBS_Maximum_servers )                          
    return SCHEDULER_CBS_ERROR_FULL;                                  
 200af98:	81 c7 e0 08 	ret                                            
 200af9c:	91 e8 3f e6 	restore  %g0, -26, %o0                         
    _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;                                   
 200afa0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
 200afa4:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  the_server->task_id = -1;                                           
  the_server->cbs_budget_overrun = budget_overrun_callback;           
 200afa8:	f2 20 60 0c 	st  %i1, [ %g1 + 0xc ]                         
    _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;                                   
 200afac:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  the_server->task_id = -1;                                           
 200afb0:	84 10 3f ff 	mov  -1, %g2                                   
 200afb4:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  the_server->cbs_budget_overrun = budget_overrun_callback;           
  return SCHEDULER_CBS_OK;                                            
 200afb8:	81 c7 e0 08 	ret                                            
 200afbc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  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;                     
 200afc0:	81 c7 e0 08 	ret                                            
 200afc4:	91 e8 3f ee 	restore  %g0, -18, %o0                         
  *server_id = i;                                                     
  _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)   
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
  the_server = _Scheduler_CBS_Server_list[*server_id];                
  if ( !the_server )                                                  
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
 200afc8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200afcc:	91 e8 3f ef 	restore  %g0, -17, %o0                         <== NOT EXECUTED
                                                                      
  if ( i == _Scheduler_CBS_Maximum_servers )                          
    return SCHEDULER_CBS_ERROR_FULL;                                  
                                                                      
  *server_id = i;                                                     
  _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)   
 200afd0:	f6 07 62 68 	ld  [ %i5 + 0x268 ], %i3                       
  }                                                                   
                                                                      
  if ( i == _Scheduler_CBS_Maximum_servers )                          
    return SCHEDULER_CBS_ERROR_FULL;                                  
                                                                      
  *server_id = i;                                                     
 200afd4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)   
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
 200afd8:	40 00 07 ad 	call  200ce8c <_Workspace_Allocate>            
 200afdc:	90 10 20 10 	mov  0x10, %o0                                 
  the_server = _Scheduler_CBS_Server_list[*server_id];                
 200afe0:	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 *)   
 200afe4:	d0 26 c0 1c 	st  %o0, [ %i3 + %i4 ]                         
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
  the_server = _Scheduler_CBS_Server_list[*server_id];                
 200afe8:	c4 07 62 68 	ld  [ %i5 + 0x268 ], %g2                       
 200afec:	83 28 60 02 	sll  %g1, 2, %g1                               
 200aff0:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
  if ( !the_server )                                                  
 200aff4:	80 a0 60 00 	cmp  %g1, 0                                    
 200aff8:	32 bf ff ea 	bne,a   200afa0 <_Scheduler_CBS_Create_server+0x60><== ALWAYS TAKEN
 200affc:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 200b000:	30 bf ff f2 	b,a   200afc8 <_Scheduler_CBS_Create_server+0x88><== NOT EXECUTED
                                                                      

0200b078 <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) {
 200b078:	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);                       
 200b07c:	90 10 00 19 	mov  %i1, %o0                                  
 200b080:	40 00 03 79 	call  200be64 <_Thread_Get>                    
 200b084:	92 07 bf fc 	add  %fp, -4, %o1                              
  /* The routine _Thread_Get may disable dispatch and not enable again. */
  if ( the_thread ) {                                                 
 200b088:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200b08c:	02 80 00 05 	be  200b0a0 <_Scheduler_CBS_Detach_thread+0x28>
 200b090:	03 00 80 80 	sethi  %hi(0x2020000), %g1                     
    _Thread_Enable_dispatch();                                        
 200b094:	40 00 03 68 	call  200be34 <_Thread_Enable_dispatch>        
 200b098:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if ( server_id >= _Scheduler_CBS_Maximum_servers )                  
 200b09c:	03 00 80 80 	sethi  %hi(0x2020000), %g1                     
 200b0a0:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1	! 2020080 <_Scheduler_CBS_Maximum_servers>
 200b0a4:	80 a6 00 01 	cmp  %i0, %g1                                  
 200b0a8:	1a 80 00 1b 	bcc  200b114 <_Scheduler_CBS_Detach_thread+0x9c>
 200b0ac:	80 a7 60 00 	cmp  %i5, 0                                    
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
  if ( !the_thread )                                                  
 200b0b0:	02 80 00 19 	be  200b114 <_Scheduler_CBS_Detach_thread+0x9c>
 200b0b4:	03 00 80 84 	sethi  %hi(0x2021000), %g1                     
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
  /* Server is not valid. */                                          
  if ( !_Scheduler_CBS_Server_list[server_id] )                       
 200b0b8:	c2 00 62 68 	ld  [ %g1 + 0x268 ], %g1	! 2021268 <_Scheduler_CBS_Server_list>
 200b0bc:	b1 2e 20 02 	sll  %i0, 2, %i0                               
 200b0c0:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
 200b0c4:	80 a0 60 00 	cmp  %g1, 0                                    
 200b0c8:	02 80 00 11 	be  200b10c <_Scheduler_CBS_Detach_thread+0x94>
 200b0cc:	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 )    
 200b0d0:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 200b0d4:	80 a0 80 19 	cmp  %g2, %i1                                  
 200b0d8:	12 80 00 0f 	bne  200b114 <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
 200b0dc:	84 10 3f ff 	mov  -1, %g2                                   
    return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;                     
                                                                      
  _Scheduler_CBS_Server_list[server_id]->task_id = -1;                
 200b0e0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
  sched_info->cbs_server = NULL;                                      
 200b0e4:	c2 07 60 88 	ld  [ %i5 + 0x88 ], %g1                        
 200b0e8:	c0 20 60 18 	clr  [ %g1 + 0x18 ]                            
                                                                      
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
 200b0ec:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
 200b0f0:	c2 27 60 78 	st  %g1, [ %i5 + 0x78 ]                        
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
 200b0f4:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        
 200b0f8:	c2 27 60 7c 	st  %g1, [ %i5 + 0x7c ]                        
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
 200b0fc:	c2 0f 60 9c 	ldub  [ %i5 + 0x9c ], %g1                      
 200b100:	c2 2f 60 70 	stb  %g1, [ %i5 + 0x70 ]                       
                                                                      
  return SCHEDULER_CBS_OK;                                            
 200b104:	81 c7 e0 08 	ret                                            
 200b108:	91 e8 20 00 	restore  %g0, 0, %o0                           
    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] )                       
    return SCHEDULER_CBS_ERROR_NOSERVER;                              
 200b10c:	81 c7 e0 08 	ret                                            
 200b110:	91 e8 3f e7 	restore  %g0, -25, %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;                                            
}                                                                     
 200b114:	81 c7 e0 08 	ret                                            
 200b118:	91 e8 3f ee 	restore  %g0, -18, %o0                         
                                                                      

0200b3a4 <_Scheduler_CBS_Initialize>: } } int _Scheduler_CBS_Initialize(void) {
 200b3a4:	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*) );
 200b3a8:	3b 00 80 80 	sethi  %hi(0x2020000), %i5                     
 200b3ac:	d0 07 60 80 	ld  [ %i5 + 0x80 ], %o0	! 2020080 <_Scheduler_CBS_Maximum_servers>
}                                                                     
                                                                      
int _Scheduler_CBS_Initialize(void)                                   
{                                                                     
  unsigned int i;                                                     
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
 200b3b0:	40 00 06 b7 	call  200ce8c <_Workspace_Allocate>            
 200b3b4:	91 2a 20 02 	sll  %o0, 2, %o0                               
 200b3b8:	05 00 80 84 	sethi  %hi(0x2021000), %g2                     
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
  if ( !_Scheduler_CBS_Server_list )                                  
 200b3bc:	80 a2 20 00 	cmp  %o0, 0                                    
 200b3c0:	02 80 00 0d 	be  200b3f4 <_Scheduler_CBS_Initialize+0x50>   <== NEVER TAKEN
 200b3c4:	d0 20 a2 68 	st  %o0, [ %g2 + 0x268 ]                       
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
  for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {                
 200b3c8:	c6 07 60 80 	ld  [ %i5 + 0x80 ], %g3                        
 200b3cc:	10 80 00 05 	b  200b3e0 <_Scheduler_CBS_Initialize+0x3c>    
 200b3d0:	82 10 20 00 	clr  %g1                                       
    _Scheduler_CBS_Server_list[i] = NULL;                             
 200b3d4:	89 28 60 02 	sll  %g1, 2, %g4                               
  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++) {                
 200b3d8:	82 00 60 01 	inc  %g1                                       
    _Scheduler_CBS_Server_list[i] = NULL;                             
 200b3dc:	c0 27 40 04 	clr  [ %i5 + %g4 ]                             
  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++) {                
 200b3e0:	80 a0 40 03 	cmp  %g1, %g3                                  
 200b3e4:	12 bf ff fc 	bne  200b3d4 <_Scheduler_CBS_Initialize+0x30>  
 200b3e8:	fa 00 a2 68 	ld  [ %g2 + 0x268 ], %i5                       
    _Scheduler_CBS_Server_list[i] = NULL;                             
  }                                                                   
  return SCHEDULER_CBS_OK;                                            
 200b3ec:	81 c7 e0 08 	ret                                            
 200b3f0:	91 e8 20 00 	restore  %g0, 0, %o0                           
}                                                                     
 200b3f4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200b3f8:	91 e8 3f ef 	restore  %g0, -17, %o0                         <== NOT EXECUTED
                                                                      

0200a028 <_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;
 200a028:	c2 02 20 88 	ld  [ %o0 + 0x88 ], %g1                        
                                                                      
  if (deadline) {                                                     
 200a02c:	80 a2 60 00 	cmp  %o1, 0                                    
 200a030:	02 80 00 10 	be  200a070 <_Scheduler_CBS_Release_job+0x48>  
 200a034:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
    /* Initializing or shifting deadline. */                          
    if (serv_info)                                                    
 200a038:	80 a0 60 00 	cmp  %g1, 0                                    
 200a03c:	02 80 00 08 	be  200a05c <_Scheduler_CBS_Release_job+0x34>  
 200a040:	05 00 80 7c 	sethi  %hi(0x201f000), %g2                     
      new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
 200a044:	d2 00 a2 bc 	ld  [ %g2 + 0x2bc ], %o1	! 201f2bc <_Watchdog_Ticks_since_boot>
 200a048:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
 200a04c:	92 02 40 02 	add  %o1, %g2, %o1                             
 200a050:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
 200a054:	10 80 00 0a 	b  200a07c <_Scheduler_CBS_Release_job+0x54>   
 200a058:	92 2a 40 02 	andn  %o1, %g2, %o1                            
        & ~SCHEDULER_EDF_PRIO_MSB;                                    
    else                                                              
      new_priority = (_Watchdog_Ticks_since_boot + deadline)          
 200a05c:	c2 00 a2 bc 	ld  [ %g2 + 0x2bc ], %g1                       
 200a060:	92 02 40 01 	add  %o1, %g1, %o1                             
 200a064:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
 200a068:	10 80 00 07 	b  200a084 <_Scheduler_CBS_Release_job+0x5c>   
 200a06c:	92 2a 40 01 	andn  %o1, %g1, %o1                            
    /* Switch back to background priority. */                         
    new_priority = the_thread->Start.initial_priority;                
  }                                                                   
                                                                      
  /* Budget replenishment for the next job. */                        
  if (serv_info)                                                      
 200a070:	80 a0 60 00 	cmp  %g1, 0                                    
 200a074:	02 80 00 04 	be  200a084 <_Scheduler_CBS_Release_job+0x5c>  <== NEVER TAKEN
 200a078:	d2 02 20 ac 	ld  [ %o0 + 0xac ], %o1                        
    the_thread->cpu_time_budget = serv_info->parameters.budget;       
 200a07c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 200a080:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
                                                                      
  the_thread->real_priority = new_priority;                           
 200a084:	d2 22 20 18 	st  %o1, [ %o0 + 0x18 ]                        
  _Thread_Change_priority(the_thread, new_priority, true);            
 200a088:	94 10 20 01 	mov  1, %o2                                    
 200a08c:	82 13 c0 00 	mov  %o7, %g1                                  
 200a090:	40 00 01 26 	call  200a528 <_Thread_Change_priority>        
 200a094:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

0200a098 <_Scheduler_CBS_Unblock>: #include <rtems/score/schedulercbs.h> void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) {
 200a098:	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);                                 
 200a09c:	40 00 00 4c 	call  200a1cc <_Scheduler_EDF_Enqueue>         
 200a0a0:	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;        
 200a0a4:	c2 06 20 88 	ld  [ %i0 + 0x88 ], %g1                        
 200a0a8:	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) {                                                    
 200a0ac:	80 a7 60 00 	cmp  %i5, 0                                    
 200a0b0:	02 80 00 18 	be  200a110 <_Scheduler_CBS_Unblock+0x78>      
 200a0b4:	03 00 80 7c 	sethi  %hi(0x201f000), %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 ) {              
 200a0b8:	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 -                  
 200a0bc:	d0 00 62 bc 	ld  [ %g1 + 0x2bc ], %o0                       
 200a0c0:	f8 06 20 18 	ld  [ %i0 + 0x18 ], %i4                        
                           _Watchdog_Ticks_since_boot;                
                                                                      
    if ( deadline*budget_left > budget*deadline_left ) {              
 200a0c4:	40 00 3f 36 	call  2019d9c <.umul>                          
 200a0c8:	90 27 00 08 	sub  %i4, %o0, %o0                             
 200a0cc:	d2 06 20 74 	ld  [ %i0 + 0x74 ], %o1                        
 200a0d0:	b6 10 00 08 	mov  %o0, %i3                                  
 200a0d4:	40 00 3f 32 	call  2019d9c <.umul>                          
 200a0d8:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
 200a0dc:	80 a6 c0 08 	cmp  %i3, %o0                                  
 200a0e0:	24 80 00 0d 	ble,a   200a114 <_Scheduler_CBS_Unblock+0x7c>  
 200a0e4:	3b 00 80 7d 	sethi  %hi(0x201f400), %i5                     
      /* Put late unblocked task to background until the end of period. */
      new_priority = the_thread->Start.initial_priority;              
 200a0e8:	d2 06 20 ac 	ld  [ %i0 + 0xac ], %o1                        
      if ( the_thread->real_priority != new_priority )                
 200a0ec:	80 a7 00 09 	cmp  %i4, %o1                                  
 200a0f0:	32 80 00 02 	bne,a   200a0f8 <_Scheduler_CBS_Unblock+0x60>  
 200a0f4:	d2 26 20 18 	st  %o1, [ %i0 + 0x18 ]                        
        the_thread->real_priority = new_priority;                     
      if ( the_thread->current_priority != new_priority )             
 200a0f8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 200a0fc:	80 a0 40 09 	cmp  %g1, %o1                                  
 200a100:	02 80 00 04 	be  200a110 <_Scheduler_CBS_Unblock+0x78>      
 200a104:	90 10 00 18 	mov  %i0, %o0                                  
        _Thread_Change_priority(the_thread, new_priority, true);      
 200a108:	40 00 01 08 	call  200a528 <_Thread_Change_priority>        
 200a10c:	94 10 20 01 	mov  1, %o2                                    
   *    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,
 200a110:	3b 00 80 7d 	sethi  %hi(0x201f400), %i5                     
 200a114:	ba 17 62 f0 	or  %i5, 0x2f0, %i5	! 201f6f0 <_Per_CPU_Information>
 200a118:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 200a11c:	03 00 80 79 	sethi  %hi(0x201e400), %g1                     
 200a120:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
 200a124:	c2 00 61 64 	ld  [ %g1 + 0x164 ], %g1                       
 200a128:	9f c0 40 00 	call  %g1                                      
 200a12c:	d2 00 a0 14 	ld  [ %g2 + 0x14 ], %o1                        
 200a130:	80 a2 20 00 	cmp  %o0, 0                                    
 200a134:	04 80 00 0f 	ble  200a170 <_Scheduler_CBS_Unblock+0xd8>     
 200a138:	01 00 00 00 	nop                                            
       _Thread_Heir->current_priority)) {                             
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
 200a13c:	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;                                        
 200a140:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
    if ( _Thread_Executing->is_preemptible ||                         
 200a144:	c2 08 60 70 	ldub  [ %g1 + 0x70 ], %g1                      
 200a148:	80 a0 60 00 	cmp  %g1, 0                                    
 200a14c:	12 80 00 06 	bne  200a164 <_Scheduler_CBS_Unblock+0xcc>     
 200a150:	84 10 20 01 	mov  1, %g2                                    
 200a154:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 200a158:	80 a0 60 00 	cmp  %g1, 0                                    
 200a15c:	12 80 00 05 	bne  200a170 <_Scheduler_CBS_Unblock+0xd8>     <== ALWAYS TAKEN
 200a160:	01 00 00 00 	nop                                            
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
 200a164:	03 00 80 7d 	sethi  %hi(0x201f400), %g1                     
 200a168:	82 10 62 f0 	or  %g1, 0x2f0, %g1	! 201f6f0 <_Per_CPU_Information>
 200a16c:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
 200a170:	81 c7 e0 08 	ret                                            
 200a174:	81 e8 00 00 	restore                                        
                                                                      

02009ff8 <_Scheduler_EDF_Allocate>: #include <rtems/score/wkspace.h> void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) {
 2009ff8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *sched;                                                        
  Scheduler_EDF_Per_thread *schinfo;                                  
                                                                      
  sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );    
 2009ffc:	40 00 06 90 	call  200ba3c <_Workspace_Allocate>            
 200a000:	90 10 20 18 	mov  0x18, %o0                                 
                                                                      
  if ( sched ) {                                                      
 200a004:	80 a2 20 00 	cmp  %o0, 0                                    
 200a008:	02 80 00 05 	be  200a01c <_Scheduler_EDF_Allocate+0x24>     <== NEVER TAKEN
 200a00c:	82 10 20 02 	mov  2, %g1                                    
    the_thread->scheduler_info = sched;                               
 200a010:	d0 26 20 88 	st  %o0, [ %i0 + 0x88 ]                        
    schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
    schinfo->thread = the_thread;                                     
 200a014:	f0 22 00 00 	st  %i0, [ %o0 ]                               
    schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;  
 200a018:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
  }                                                                   
                                                                      
  return sched;                                                       
}                                                                     
 200a01c:	81 c7 e0 08 	ret                                            
 200a020:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0200a1c0 <_Scheduler_EDF_Unblock>: #include <rtems/score/scheduleredf.h> void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) {
 200a1c0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  _Scheduler_EDF_Enqueue(the_thread);                                 
 200a1c4:	7f ff ff ad 	call  200a078 <_Scheduler_EDF_Enqueue>         
 200a1c8:	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(                             
 200a1cc:	3b 00 80 7d 	sethi  %hi(0x201f400), %i5                     
 200a1d0:	ba 17 62 30 	or  %i5, 0x230, %i5	! 201f630 <_Per_CPU_Information>
 200a1d4:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 200a1d8:	03 00 80 79 	sethi  %hi(0x201e400), %g1                     
 200a1dc:	d0 00 a0 14 	ld  [ %g2 + 0x14 ], %o0                        
 200a1e0:	c2 00 60 b4 	ld  [ %g1 + 0xb4 ], %g1                        
 200a1e4:	9f c0 40 00 	call  %g1                                      
 200a1e8:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
 200a1ec:	80 a2 20 00 	cmp  %o0, 0                                    
 200a1f0:	16 80 00 0f 	bge  200a22c <_Scheduler_EDF_Unblock+0x6c>     
 200a1f4:	01 00 00 00 	nop                                            
         _Thread_Heir->current_priority,                              
         the_thread->current_priority )) {                            
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
 200a1f8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
   *    a pseudo-ISR system task, we need to do a context switch.     
   */                                                                 
  if ( _Scheduler_Is_priority_lower_than(                             
         _Thread_Heir->current_priority,                              
         the_thread->current_priority )) {                            
    _Thread_Heir = the_thread;                                        
 200a1fc:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
    if ( _Thread_Executing->is_preemptible ||                         
 200a200:	c2 08 60 70 	ldub  [ %g1 + 0x70 ], %g1                      
 200a204:	80 a0 60 00 	cmp  %g1, 0                                    
 200a208:	12 80 00 06 	bne  200a220 <_Scheduler_EDF_Unblock+0x60>     
 200a20c:	84 10 20 01 	mov  1, %g2                                    
 200a210:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 200a214:	80 a0 60 00 	cmp  %g1, 0                                    
 200a218:	12 80 00 05 	bne  200a22c <_Scheduler_EDF_Unblock+0x6c>     <== ALWAYS TAKEN
 200a21c:	01 00 00 00 	nop                                            
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
 200a220:	03 00 80 7d 	sethi  %hi(0x201f400), %g1                     
 200a224:	82 10 62 30 	or  %g1, 0x230, %g1	! 201f630 <_Per_CPU_Information>
 200a228:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
 200a22c:	81 c7 e0 08 	ret                                            
 200a230:	81 e8 00 00 	restore                                        
                                                                      

020098cc <_Scheduler_priority_Tick>: #include <rtems/system.h> #include <rtems/score/schedulerpriority.h> void _Scheduler_priority_Tick( void ) {
 20098cc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Thread_Control *executing;                                          
                                                                      
  executing = _Thread_Executing;                                      
 20098d0:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 20098d4:	fa 00 63 00 	ld  [ %g1 + 0x300 ], %i5	! 201db00 <_Per_CPU_Information+0x10>
  /*                                                                  
   *  If the thread is not preemptible or is not ready, then          
   *  just return.                                                    
   */                                                                 
                                                                      
  if ( !executing->is_preemptible )                                   
 20098d8:	c2 0f 60 70 	ldub  [ %i5 + 0x70 ], %g1                      
 20098dc:	80 a0 60 00 	cmp  %g1, 0                                    
 20098e0:	02 80 00 25 	be  2009974 <_Scheduler_priority_Tick+0xa8>    
 20098e4:	01 00 00 00 	nop                                            
    return;                                                           
                                                                      
  if ( !_States_Is_ready( executing->current_state ) )                
 20098e8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 20098ec:	80 a0 60 00 	cmp  %g1, 0                                    
 20098f0:	12 80 00 21 	bne  2009974 <_Scheduler_priority_Tick+0xa8>   
 20098f4:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  The cpu budget algorithm determines what happens next.          
   */                                                                 
                                                                      
  switch ( executing->budget_algorithm ) {                            
 20098f8:	c2 07 60 78 	ld  [ %i5 + 0x78 ], %g1                        
 20098fc:	80 a0 60 01 	cmp  %g1, 1                                    
 2009900:	0a 80 00 14 	bcs  2009950 <_Scheduler_priority_Tick+0x84>   
 2009904:	80 a0 60 02 	cmp  %g1, 2                                    
 2009908:	28 80 00 07 	bleu,a   2009924 <_Scheduler_priority_Tick+0x58>
 200990c:	c2 07 60 74 	ld  [ %i5 + 0x74 ], %g1                        
 2009910:	80 a0 60 03 	cmp  %g1, 3                                    
 2009914:	12 80 00 18 	bne  2009974 <_Scheduler_priority_Tick+0xa8>   <== NEVER TAKEN
 2009918:	01 00 00 00 	nop                                            
      }                                                               
      break;                                                          
                                                                      
    #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)          
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	if ( --executing->cpu_time_budget == 0 )                             
 200991c:	10 80 00 0f 	b  2009958 <_Scheduler_priority_Tick+0x8c>     
 2009920:	c2 07 60 74 	ld  [ %i5 + 0x74 ], %g1                        
                                                                      
    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 ) {               
 2009924:	82 00 7f ff 	add  %g1, -1, %g1                              
 2009928:	80 a0 60 00 	cmp  %g1, 0                                    
 200992c:	14 80 00 09 	bg  2009950 <_Scheduler_priority_Tick+0x84>    
 2009930:	c2 27 60 74 	st  %g1, [ %i5 + 0x74 ]                        
 *  always operates on the scheduler that 'owns' the currently executing
 *  thread.                                                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )                    
{                                                                     
  _Scheduler.Operations.yield();                                      
 2009934:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2009938:	c2 00 61 c0 	ld  [ %g1 + 0x1c0 ], %g1	! 201c9c0 <_Scheduler+0xc>
 200993c:	9f c0 40 00 	call  %g1                                      
 2009940:	01 00 00 00 	nop                                            
         *  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;     
 2009944:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2009948:	c2 00 61 30 	ld  [ %g1 + 0x130 ], %g1	! 201d530 <_Thread_Ticks_per_timeslice>
 200994c:	c2 27 60 74 	st  %g1, [ %i5 + 0x74 ]                        
 2009950:	81 c7 e0 08 	ret                                            
 2009954:	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 )                             
 2009958:	82 00 7f ff 	add  %g1, -1, %g1                              
 200995c:	80 a0 60 00 	cmp  %g1, 0                                    
 2009960:	12 bf ff fc 	bne  2009950 <_Scheduler_priority_Tick+0x84>   
 2009964:	c2 27 60 74 	st  %g1, [ %i5 + 0x74 ]                        
	  (*executing->budget_callout)( executing );                         
 2009968:	c2 07 60 7c 	ld  [ %i5 + 0x7c ], %g1                        
 200996c:	9f c0 40 00 	call  %g1                                      
 2009970:	90 10 00 1d 	mov  %i5, %o0                                  
 2009974:	81 c7 e0 08 	ret                                            
 2009978:	81 e8 00 00 	restore                                        
                                                                      

02008490 <_TOD_Validate>: }; bool _TOD_Validate( const rtems_time_of_day *the_tod ) {
 2008490:	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 /                    
 2008494:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2008498:	d2 00 61 fc 	ld  [ %g1 + 0x1fc ], %o1	! 201c9fc <Configuration+0xc>
 200849c:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
 20084a0:	40 00 48 86 	call  201a6b8 <.udiv>                          
 20084a4:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
 20084a8:	80 a6 20 00 	cmp  %i0, 0                                    
 20084ac:	02 80 00 28 	be  200854c <_TOD_Validate+0xbc>               <== NEVER TAKEN
 20084b0:	84 10 20 00 	clr  %g2                                       
 20084b4:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 20084b8:	80 a0 40 08 	cmp  %g1, %o0                                  
 20084bc:	3a 80 00 25 	bcc,a   2008550 <_TOD_Validate+0xc0>           
 20084c0:	b0 08 a0 01 	and  %g2, 1, %i0                               
      (the_tod->ticks  >= ticks_per_second)       ||                  
 20084c4:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 20084c8:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
 20084cc:	38 80 00 21 	bgu,a   2008550 <_TOD_Validate+0xc0>           
 20084d0:	b0 08 a0 01 	and  %g2, 1, %i0                               
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
 20084d4:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
 20084d8:	80 a0 60 3b 	cmp  %g1, 0x3b                                 
 20084dc:	38 80 00 1d 	bgu,a   2008550 <_TOD_Validate+0xc0>           
 20084e0:	b0 08 a0 01 	and  %g2, 1, %i0                               
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
 20084e4:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 20084e8:	80 a0 60 17 	cmp  %g1, 0x17                                 
 20084ec:	38 80 00 19 	bgu,a   2008550 <_TOD_Validate+0xc0>           
 20084f0:	b0 08 a0 01 	and  %g2, 1, %i0                               
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
 20084f4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
	    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)      ||                  
 20084f8:	80 a0 60 00 	cmp  %g1, 0                                    
 20084fc:	02 80 00 14 	be  200854c <_TOD_Validate+0xbc>               <== NEVER TAKEN
 2008500:	80 a0 60 0c 	cmp  %g1, 0xc                                  
      (the_tod->month  == 0)                      ||                  
 2008504:	38 80 00 13 	bgu,a   2008550 <_TOD_Validate+0xc0>           
 2008508:	b0 08 a0 01 	and  %g2, 1, %i0                               
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
 200850c:	c8 06 00 00 	ld  [ %i0 ], %g4                               
      (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)    ||                  
 2008510:	80 a1 27 c3 	cmp  %g4, 0x7c3                                
 2008514:	28 80 00 0f 	bleu,a   2008550 <_TOD_Validate+0xc0>          
 2008518:	b0 08 a0 01 	and  %g2, 1, %i0                               
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
 200851c:	c6 06 20 08 	ld  [ %i0 + 8 ], %g3                           
      (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)          ||                  
 2008520:	80 a0 e0 00 	cmp  %g3, 0                                    
 2008524:	02 80 00 0a 	be  200854c <_TOD_Validate+0xbc>               <== NEVER TAKEN
 2008528:	80 89 20 03 	btst  3, %g4                                   
 200852c:	05 00 80 76 	sethi  %hi(0x201d800), %g2                     
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
 2008530:	12 80 00 03 	bne  200853c <_TOD_Validate+0xac>              
 2008534:	84 10 a3 f0 	or  %g2, 0x3f0, %g2	! 201dbf0 <_TOD_Days_per_month>
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
 2008538:	82 00 60 0d 	add  %g1, 0xd, %g1                             
  else                                                                
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];       
 200853c:	83 28 60 02 	sll  %g1, 2, %g1                               
 2008540:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
                                                                      
  if ( the_tod->day > days_in_month )                                 
 2008544:	80 a0 40 03 	cmp  %g1, %g3                                  
 2008548:	84 60 3f ff 	subx  %g0, -1, %g2                             
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
 200854c:	b0 08 a0 01 	and  %g2, 1, %i0                               
 2008550:	81 c7 e0 08 	ret                                            
 2008554:	81 e8 00 00 	restore                                        
                                                                      

02009b88 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) {
 2009b88:	9d e3 bf a0 	save  %sp, -96, %sp                            
 2009b8c:	ba 10 00 18 	mov  %i0, %i5                                  
  States_Control state, original_state;                               
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
 2009b90:	f0 06 20 10 	ld  [ %i0 + 0x10 ], %i0                        
  /*                                                                  
   * 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 );                                
 2009b94:	40 00 03 78 	call  200a974 <_Thread_Set_transient>          
 2009b98:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  /*                                                                  
   *  Do not bother recomputing all the priority related information if
   *  we are not REALLY changing priority.                            
   */                                                                 
 if ( the_thread->current_priority != new_priority )                  
 2009b9c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2009ba0:	80 a0 40 19 	cmp  %g1, %i1                                  
 2009ba4:	02 80 00 04 	be  2009bb4 <_Thread_Change_priority+0x2c>     
 2009ba8:	90 10 00 1d 	mov  %i5, %o0                                  
    _Thread_Set_priority( the_thread, new_priority );                 
 2009bac:	40 00 03 59 	call  200a910 <_Thread_Set_priority>           
 2009bb0:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  _ISR_Disable( level );                                              
 2009bb4:	7f ff e2 84 	call  20025c4 <sparc_disable_interrupts>       
 2009bb8:	01 00 00 00 	nop                                            
 2009bbc:	b6 10 00 08 	mov  %o0, %i3                                  
                                                                      
  /*                                                                  
   *  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;                                  
 2009bc0:	f8 07 60 10 	ld  [ %i5 + 0x10 ], %i4                        
  if ( state != STATES_TRANSIENT ) {                                  
 2009bc4:	80 a7 20 04 	cmp  %i4, 4                                    
 2009bc8:	02 80 00 10 	be  2009c08 <_Thread_Change_priority+0x80>     
 2009bcc:	82 0e 20 04 	and  %i0, 4, %g1                               
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
 2009bd0:	80 a0 60 00 	cmp  %g1, 0                                    
 2009bd4:	12 80 00 03 	bne  2009be0 <_Thread_Change_priority+0x58>    <== NEVER TAKEN
 2009bd8:	82 0f 3f fb 	and  %i4, -5, %g1                              
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
 2009bdc:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
    _ISR_Enable( level );                                             
 2009be0:	7f ff e2 7d 	call  20025d4 <sparc_enable_interrupts>        
 2009be4:	90 10 00 1b 	mov  %i3, %o0                                  
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
 2009be8:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
 2009bec:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
 2009bf0:	80 8f 00 01 	btst  %i4, %g1                                 
 2009bf4:	02 80 00 27 	be  2009c90 <_Thread_Change_priority+0x108>    
 2009bf8:	01 00 00 00 	nop                                            
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
 2009bfc:	f0 07 60 44 	ld  [ %i5 + 0x44 ], %i0                        
 2009c00:	40 00 03 17 	call  200a85c <_Thread_queue_Requeue>          
 2009c04:	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 ) ) {                   
 2009c08:	80 a0 60 00 	cmp  %g1, 0                                    
 2009c0c:	12 80 00 0b 	bne  2009c38 <_Thread_Change_priority+0xb0>    <== NEVER TAKEN
 2009c10:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
     *  Interrupts are STILL disabled.                                
     *  We now know the thread will be in the READY state when we remove
     *  the TRANSIENT state.  So we have to place it on the appropriate
     *  Ready Queue with interrupts off.                              
     */                                                               
    the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
 2009c14:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
                                                                      
    if ( prepend_it )                                                 
 2009c18:	80 a6 a0 00 	cmp  %i2, 0                                    
 2009c1c:	02 80 00 04 	be  2009c2c <_Thread_Change_priority+0xa4>     
 2009c20:	82 10 61 b4 	or  %g1, 0x1b4, %g1                            
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(                   
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue_first( the_thread );                  
 2009c24:	10 80 00 03 	b  2009c30 <_Thread_Change_priority+0xa8>      
 2009c28:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue( the_thread );                        
 2009c2c:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
 2009c30:	9f c0 40 00 	call  %g1                                      
 2009c34:	90 10 00 1d 	mov  %i5, %o0                                  
      _Scheduler_Enqueue_first( the_thread );                         
    else                                                              
      _Scheduler_Enqueue( the_thread );                               
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
 2009c38:	7f ff e2 67 	call  20025d4 <sparc_enable_interrupts>        
 2009c3c:	90 10 00 1b 	mov  %i3, %o0                                  
 2009c40:	7f ff e2 61 	call  20025c4 <sparc_disable_interrupts>       
 2009c44:	01 00 00 00 	nop                                            
 2009c48:	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();                                   
 2009c4c:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2009c50:	c2 00 61 bc 	ld  [ %g1 + 0x1bc ], %g1	! 201c9bc <_Scheduler+0x8>
 2009c54:	9f c0 40 00 	call  %g1                                      
 2009c58:	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 );                       
 2009c5c:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 2009c60:	82 10 62 f0 	or  %g1, 0x2f0, %g1	! 201daf0 <_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() &&                       
 2009c64:	c4 18 60 10 	ldd  [ %g1 + 0x10 ], %g2                       
 2009c68:	80 a0 80 03 	cmp  %g2, %g3                                  
 2009c6c:	02 80 00 07 	be  2009c88 <_Thread_Change_priority+0x100>    
 2009c70:	01 00 00 00 	nop                                            
 2009c74:	c4 08 a0 70 	ldub  [ %g2 + 0x70 ], %g2                      
 2009c78:	80 a0 a0 00 	cmp  %g2, 0                                    
 2009c7c:	02 80 00 03 	be  2009c88 <_Thread_Change_priority+0x100>    
 2009c80:	84 10 20 01 	mov  1, %g2                                    
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
 2009c84:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
  _ISR_Enable( level );                                               
 2009c88:	7f ff e2 53 	call  20025d4 <sparc_enable_interrupts>        
 2009c8c:	81 e8 00 00 	restore                                        
 2009c90:	81 c7 e0 08 	ret                                            
 2009c94:	81 e8 00 00 	restore                                        
                                                                      

02009e78 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) {
 2009e78:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 2009e7c:	90 10 00 18 	mov  %i0, %o0                                  
 2009e80:	40 00 00 80 	call  200a080 <_Thread_Get>                    
 2009e84:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 2009e88:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2009e8c:	80 a0 60 00 	cmp  %g1, 0                                    
 2009e90:	12 80 00 08 	bne  2009eb0 <_Thread_Delay_ended+0x38>        <== NEVER TAKEN
 2009e94:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
 2009e98:	7f ff ff 80 	call  2009c98 <_Thread_Clear_state>            
 2009e9c:	92 12 60 18 	or  %o1, 0x18, %o1	! 10000018 <RAM_END+0xdc00018>
   *                                                                  
   * 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;                  
 2009ea0:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2009ea4:	c4 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g2	! 201d5d0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
 2009ea8:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
 2009eac:	c4 20 61 d0 	st  %g2, [ %g1 + 0x1d0 ]                       
 2009eb0:	81 c7 e0 08 	ret                                            
 2009eb4:	81 e8 00 00 	restore                                        
                                                                      

02009eb8 <_Thread_Dispatch>: #if defined(RTEMS_SMP) #include <rtems/score/smp.h> #endif void _Thread_Dispatch( void ) {
 2009eb8:	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;                                    
 2009ebc:	35 00 80 76 	sethi  %hi(0x201d800), %i2                     
 2009ec0:	82 16 a2 f0 	or  %i2, 0x2f0, %g1	! 201daf0 <_Per_CPU_Information>
  _ISR_Disable( level );                                              
 2009ec4:	7f ff e1 c0 	call  20025c4 <sparc_disable_interrupts>       
 2009ec8:	f6 00 60 10 	ld  [ %g1 + 0x10 ], %i3                        
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
 2009ecc:	21 00 80 75 	sethi  %hi(0x201d400), %l0                     
{                                                                     
  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 ) {                                            
 2009ed0:	27 00 80 72 	sethi  %hi(0x201c800), %l3                     
   * 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;                           
 2009ed4:	33 00 80 75 	sethi  %hi(0x201d400), %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;            
 2009ed8:	31 00 80 75 	sethi  %hi(0x201d400), %i0                     
 2009edc:	a0 14 21 20 	or  %l0, 0x120, %l0                            
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
 2009ee0:	23 00 80 75 	sethi  %hi(0x201d400), %l1                     
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 2009ee4:	25 00 80 72 	sethi  %hi(0x201c800), %l2                     
  /*                                                                  
   *  Now determine if we need to perform a dispatch on the current CPU.
   */                                                                 
  executing   = _Thread_Executing;                                    
  _ISR_Disable( level );                                              
  while ( _Thread_Dispatch_necessary == true ) {                      
 2009ee8:	10 80 00 4b 	b  200a014 <_Thread_Dispatch+0x15c>            
 2009eec:	a6 14 e3 8c 	or  %l3, 0x38c, %l3                            
 2009ef0:	84 10 20 01 	mov  1, %g2                                    
 2009ef4:	c4 26 61 d0 	st  %g2, [ %i1 + 0x1d0 ]                       
    heir = _Thread_Heir;                                              
    #ifndef RTEMS_SMP                                                 
      _Thread_Dispatch_set_disable_level( 1 );                        
    #endif                                                            
    _Thread_Dispatch_necessary = false;                               
 2009ef8:	c0 28 60 0c 	clrb  [ %g1 + 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 )                                          
 2009efc:	80 a5 00 1b 	cmp  %l4, %i3                                  
 2009f00:	12 80 00 0a 	bne  2009f28 <_Thread_Dispatch+0x70>           
 2009f04:	e8 20 60 10 	st  %l4, [ %g1 + 0x10 ]                        
 2009f08:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2009f0c:	c0 20 61 d0 	clr  [ %g1 + 0x1d0 ]	! 201d5d0 <_Thread_Dispatch_disable_level>
post_switch:                                                          
  #ifndef RTEMS_SMP                                                   
    _Thread_Dispatch_set_disable_level( 0 );                          
  #endif                                                              
                                                                      
  _ISR_Enable( level );                                               
 2009f10:	7f ff e1 b1 	call  20025d4 <sparc_enable_interrupts>        
 2009f14:	39 00 80 75 	sethi  %hi(0x201d400), %i4                     
 2009f18:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2009f1c:	fa 00 62 44 	ld  [ %g1 + 0x244 ], %i5	! 201d644 <_API_extensions_Post_switch_list>
{                                                                     
  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 ) {                                            
 2009f20:	10 80 00 47 	b  200a03c <_Thread_Dispatch+0x184>            
 2009f24:	b8 17 22 48 	or  %i4, 0x248, %i4                            
     */                                                               
#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 )
 2009f28:	c2 05 20 78 	ld  [ %l4 + 0x78 ], %g1                        
 2009f2c:	80 a0 60 01 	cmp  %g1, 1                                    
 2009f30:	12 80 00 03 	bne  2009f3c <_Thread_Dispatch+0x84>           
 2009f34:	c2 06 21 30 	ld  [ %i0 + 0x130 ], %g1                       
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
 2009f38:	c2 25 20 74 	st  %g1, [ %l4 + 0x74 ]                        
                                                                      
    _ISR_Enable( level );                                             
 2009f3c:	7f ff e1 a6 	call  20025d4 <sparc_enable_interrupts>        
 2009f40:	01 00 00 00 	nop                                            
 2009f44:	90 07 bf f8 	add  %fp, -8, %o0                              
 2009f48:	7f ff f9 b9 	call  200862c <_TOD_Get_with_nanoseconds>      
 2009f4c:	92 10 00 10 	mov  %l0, %o1                                  
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
        _Timestamp_Subtract(                                          
 2009f50:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
 2009f54:	82 16 a2 f0 	or  %i2, 0x2f0, %g1                            
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
 2009f58:	f8 18 60 20 	ldd  [ %g1 + 0x20 ], %i4                       
 2009f5c:	96 a0 c0 1d 	subcc  %g3, %i5, %o3                           
 2009f60:	94 60 80 1c 	subx  %g2, %i4, %o2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
 2009f64:	f8 1e e0 80 	ldd  [ %i3 + 0x80 ], %i4                       
 2009f68:	9a 87 40 0b 	addcc  %i5, %o3, %o5                           
 2009f6c:	98 47 00 0a 	addx  %i4, %o2, %o4                            
 2009f70:	d8 3e e0 80 	std  %o4, [ %i3 + 0x80 ]                       
          &_Thread_Time_of_last_context_switch,                       
          &uptime,                                                    
          &ran                                                        
        );                                                            
        _Timestamp_Add_to( &executing->cpu_time_used, &ran );         
        _Thread_Time_of_last_context_switch = uptime;                 
 2009f74:	c4 38 60 20 	std  %g2, [ %g1 + 0x20 ]                       
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
 2009f78:	c2 04 62 40 	ld  [ %l1 + 0x240 ], %g1                       
 2009f7c:	80 a0 60 00 	cmp  %g1, 0                                    
 2009f80:	22 80 00 0c 	be,a   2009fb0 <_Thread_Dispatch+0xf8>         <== NEVER TAKEN
 2009f84:	fa 04 a3 88 	ld  [ %l2 + 0x388 ], %i5                       <== NOT EXECUTED
      executing->libc_reent = *_Thread_libc_reent;                    
 2009f88:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 2009f8c:	c4 26 e1 54 	st  %g2, [ %i3 + 0x154 ]                       
      *_Thread_libc_reent = heir->libc_reent;                         
 2009f90:	c4 05 21 54 	ld  [ %l4 + 0x154 ], %g2                       
 2009f94:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 2009f98:	10 80 00 06 	b  2009fb0 <_Thread_Dispatch+0xf8>             
 2009f9c:	fa 04 a3 88 	ld  [ %l2 + 0x388 ], %i5                       
    const User_extensions_Switch_control *extension =                 
      (const User_extensions_Switch_control *) node;                  
                                                                      
    (*extension->thread_switch)( executing, heir );                   
 2009fa0:	90 10 00 1b 	mov  %i3, %o0                                  
 2009fa4:	9f c0 40 00 	call  %g1                                      
 2009fa8:	92 10 00 14 	mov  %l4, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_next(         
  const Chain_Node *the_node                                          
)                                                                     
{                                                                     
  return the_node->next;                                              
 2009fac:	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 ) {                                            
 2009fb0:	80 a7 40 13 	cmp  %i5, %l3                                  
 2009fb4:	32 bf ff fb 	bne,a   2009fa0 <_Thread_Dispatch+0xe8>        
 2009fb8:	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 );       
 2009fbc:	90 06 e0 c8 	add  %i3, 0xc8, %o0                            
 2009fc0:	40 00 04 90 	call  200b200 <_CPU_Context_switch>            
 2009fc4:	92 05 20 c8 	add  %l4, 0xc8, %o1                            
                                                                      
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )                            
    if ( (executing->fp_context != NULL) &&                           
 2009fc8:	c2 06 e1 50 	ld  [ %i3 + 0x150 ], %g1                       
 2009fcc:	80 a0 60 00 	cmp  %g1, 0                                    
 2009fd0:	02 80 00 0e 	be  200a008 <_Thread_Dispatch+0x150>           
 2009fd4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (                   
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Allocated_fp );                      
 2009fd8:	d0 00 62 3c 	ld  [ %g1 + 0x23c ], %o0	! 201d63c <_Thread_Allocated_fp>
 2009fdc:	80 a6 c0 08 	cmp  %i3, %o0                                  
 2009fe0:	02 80 00 0a 	be  200a008 <_Thread_Dispatch+0x150>           
 2009fe4:	80 a2 20 00 	cmp  %o0, 0                                    
         !_Thread_Is_allocated_fp( executing ) ) {                    
      if ( _Thread_Allocated_fp != NULL )                             
 2009fe8:	02 80 00 04 	be  2009ff8 <_Thread_Dispatch+0x140>           
 2009fec:	01 00 00 00 	nop                                            
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );        
 2009ff0:	40 00 04 4a 	call  200b118 <_CPU_Context_save_fp>           
 2009ff4:	90 02 21 50 	add  %o0, 0x150, %o0                           
      _Context_Restore_fp( &executing->fp_context );                  
 2009ff8:	40 00 04 65 	call  200b18c <_CPU_Context_restore_fp>        
 2009ffc:	90 06 e1 50 	add  %i3, 0x150, %o0                           
      _Thread_Allocated_fp = executing;                               
 200a000:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a004:	f6 20 62 3c 	st  %i3, [ %g1 + 0x23c ]	! 201d63c <_Thread_Allocated_fp>
    if ( executing->fp_context != NULL )                              
      _Context_Restore_fp( &executing->fp_context );                  
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
 200a008:	82 16 a2 f0 	or  %i2, 0x2f0, %g1                            
                                                                      
    _ISR_Disable( level );                                            
 200a00c:	7f ff e1 6e 	call  20025c4 <sparc_disable_interrupts>       
 200a010:	f6 00 60 10 	ld  [ %g1 + 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 ) {                      
 200a014:	82 16 a2 f0 	or  %i2, 0x2f0, %g1                            
 200a018:	c4 08 60 0c 	ldub  [ %g1 + 0xc ], %g2                       
 200a01c:	80 a0 a0 00 	cmp  %g2, 0                                    
 200a020:	32 bf ff b4 	bne,a   2009ef0 <_Thread_Dispatch+0x38>        
 200a024:	e8 00 60 14 	ld  [ %g1 + 0x14 ], %l4                        
   * 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;                           
 200a028:	10 bf ff b9 	b  2009f0c <_Thread_Dispatch+0x54>             
 200a02c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
    const API_extensions_Post_switch_control *post_switch =           
      (const API_extensions_Post_switch_control *) node;              
                                                                      
    (*post_switch->hook)( executing );                                
 200a030:	9f c0 40 00 	call  %g1                                      
 200a034:	90 10 00 1b 	mov  %i3, %o0                                  
 200a038:	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 ) {                                            
 200a03c:	80 a7 40 1c 	cmp  %i5, %i4                                  
 200a040:	32 bf ff fc 	bne,a   200a030 <_Thread_Dispatch+0x178>       
 200a044:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #ifdef RTEMS_SMP                                                    
    _Thread_Unnest_dispatch();                                        
  #endif                                                              
                                                                      
  _API_extensions_Run_post_switch( executing );                       
}                                                                     
 200a048:	81 c7 e0 08 	ret                                            
 200a04c:	81 e8 00 00 	restore                                        
                                                                      

0200f410 <_Thread_Handler>: #define INIT_NAME __main #define EXECUTE_GLOBAL_CONSTRUCTORS #endif void _Thread_Handler( void ) {
 200f410:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static bool doneConstructors;                                     
    bool doCons;                                                      
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
 200f414:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 200f418:	fa 00 63 00 	ld  [ %g1 + 0x300 ], %i5	! 201db00 <_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();                          
 200f41c:	3f 00 80 3d 	sethi  %hi(0x200f400), %i7                     
 200f420:	be 17 e0 10 	or  %i7, 0x10, %i7	! 200f410 <_Thread_Handler> 
                                                                      
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
  level = executing->Start.isr_level;                                 
 200f424:	d0 07 60 a8 	ld  [ %i5 + 0xa8 ], %o0                        
  _ISR_Set_level(level);                                              
 200f428:	7f ff cc 6b 	call  20025d4 <sparc_enable_interrupts>        
 200f42c:	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;                                     
 200f430:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
      doneConstructors = true;                                        
 200f434:	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;                                     
 200f438:	f8 08 62 d0 	ldub  [ %g1 + 0x2d0 ], %i4                     
      doneConstructors = true;                                        
 200f43c:	c4 28 62 d0 	stb  %g2, [ %g1 + 0x2d0 ]                      
    #endif                                                            
  #endif                                                              
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )                        
      if ( (executing->fp_context != NULL) &&                         
 200f440:	c2 07 61 50 	ld  [ %i5 + 0x150 ], %g1                       
 200f444:	80 a0 60 00 	cmp  %g1, 0                                    
 200f448:	02 80 00 0c 	be  200f478 <_Thread_Handler+0x68>             
 200f44c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (                   
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Allocated_fp );                      
 200f450:	d0 00 62 3c 	ld  [ %g1 + 0x23c ], %o0	! 201d63c <_Thread_Allocated_fp>
 200f454:	80 a7 40 08 	cmp  %i5, %o0                                  
 200f458:	02 80 00 08 	be  200f478 <_Thread_Handler+0x68>             
 200f45c:	80 a2 20 00 	cmp  %o0, 0                                    
            !_Thread_Is_allocated_fp( executing ) ) {                 
        if ( _Thread_Allocated_fp != NULL )                           
 200f460:	22 80 00 06 	be,a   200f478 <_Thread_Handler+0x68>          
 200f464:	fa 20 62 3c 	st  %i5, [ %g1 + 0x23c ]                       
          _Context_Save_fp( &_Thread_Allocated_fp->fp_context );      
 200f468:	7f ff ef 2c 	call  200b118 <_CPU_Context_save_fp>           
 200f46c:	90 02 21 50 	add  %o0, 0x150, %o0                           
        _Thread_Allocated_fp = executing;                             
 200f470:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200f474:	fa 20 62 3c 	st  %i5, [ %g1 + 0x23c ]	! 201d63c <_Thread_Allocated_fp>
  );                                                                  
}                                                                     
                                                                      
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{                                                                     
  _User_extensions_Iterate(                                           
 200f478:	90 10 00 1d 	mov  %i5, %o0                                  
 200f47c:	13 00 80 2a 	sethi  %hi(0x200a800), %o1                     
 200f480:	7f ff ed d9 	call  200abe4 <_User_extensions_Iterate>       
 200f484:	92 12 63 70 	or  %o1, 0x370, %o1	! 200ab70 <_User_extensions_Thread_begin_visitor>
  _User_extensions_Thread_begin( executing );                         
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
 200f488:	7f ff ea f2 	call  200a050 <_Thread_Enable_dispatch>        
 200f48c:	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) */ {                    
 200f490:	80 8f 20 ff 	btst  0xff, %i4                                
 200f494:	32 80 00 05 	bne,a   200f4a8 <_Thread_Handler+0x98>         
 200f498:	c2 07 60 90 	ld  [ %i5 + 0x90 ], %g1                        
      INIT_NAME ();                                                   
 200f49c:	40 00 35 11 	call  201c8e0 <_init>                          
 200f4a0:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
 200f4a4:	c2 07 60 90 	ld  [ %i5 + 0x90 ], %g1                        
 200f4a8:	80 a0 60 00 	cmp  %g1, 0                                    
 200f4ac:	12 80 00 05 	bne  200f4c0 <_Thread_Handler+0xb0>            
 200f4b0:	80 a0 60 01 	cmp  %g1, 1                                    
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
 200f4b4:	c2 07 60 8c 	ld  [ %i5 + 0x8c ], %g1                        
 200f4b8:	10 80 00 06 	b  200f4d0 <_Thread_Handler+0xc0>              
 200f4bc:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        
        executing->Start.numeric_argument                             
      );                                                              
  }                                                                   
  #if defined(RTEMS_POSIX_API)                                        
    else if ( executing->Start.prototype == THREAD_START_POINTER ) {  
 200f4c0:	12 80 00 08 	bne  200f4e0 <_Thread_Handler+0xd0>            <== NEVER TAKEN
 200f4c4:	90 10 00 1d 	mov  %i5, %o0                                  
      executing->Wait.return_argument =                               
        (*(Thread_Entry_pointer) executing->Start.entry_point)(       
 200f4c8:	c2 07 60 8c 	ld  [ %i5 + 0x8c ], %g1                        
 200f4cc:	d0 07 60 94 	ld  [ %i5 + 0x94 ], %o0                        
 200f4d0:	9f c0 40 00 	call  %g1                                      
 200f4d4:	01 00 00 00 	nop                                            
        executing->Start.numeric_argument                             
      );                                                              
  }                                                                   
  #if defined(RTEMS_POSIX_API)                                        
    else if ( executing->Start.prototype == THREAD_START_POINTER ) {  
      executing->Wait.return_argument =                               
 200f4d8:	d0 27 60 28 	st  %o0, [ %i5 + 0x28 ]                        
  }                                                                   
}                                                                     
                                                                      
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{                                                                     
  _User_extensions_Iterate(                                           
 200f4dc:	90 10 00 1d 	mov  %i5, %o0                                  
 200f4e0:	13 00 80 2a 	sethi  %hi(0x200a800), %o1                     
 200f4e4:	7f ff ed c0 	call  200abe4 <_User_extensions_Iterate>       
 200f4e8:	92 12 63 94 	or  %o1, 0x394, %o1	! 200ab94 <_User_extensions_Thread_exitted_visitor>
   *  able to fit in a (void *).                                      
   */                                                                 
                                                                      
  _User_extensions_Thread_exitted( executing );                       
                                                                      
  _Internal_error_Occurred(                                           
 200f4ec:	90 10 20 00 	clr  %o0                                       
 200f4f0:	92 10 20 01 	mov  1, %o1                                    
 200f4f4:	7f ff e5 82 	call  2008afc <_Internal_error_Occurred>       
 200f4f8:	94 10 20 05 	mov  5, %o2                                    
                                                                      

0200a33c <_Thread_Handler_initialization>: #if defined(RTEMS_SMP) #include <rtems/bspsmp.h> #endif void _Thread_Handler_initialization(void) {
 200a33c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uint32_t ticks_per_timeslice =                                      
 200a340:	03 00 80 69 	sethi  %hi(0x201a400), %g1                     
 200a344:	82 10 63 78 	or  %g1, 0x378, %g1	! 201a778 <Configuration>  
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t maximum_proxies =                                        
      _Configuration_MP_table->maximum_proxies;                       
  #endif                                                              
                                                                      
  if ( rtems_configuration_get_stack_allocate_hook() == NULL ||       
 200a348:	c6 00 60 28 	ld  [ %g1 + 0x28 ], %g3                        
  #include <rtems/bspsmp.h>                                           
#endif                                                                
                                                                      
void _Thread_Handler_initialization(void)                             
{                                                                     
  uint32_t ticks_per_timeslice =                                      
 200a34c:	fa 00 60 14 	ld  [ %g1 + 0x14 ], %i5                        
    rtems_configuration_get_ticks_per_timeslice();                    
  uint32_t maximum_extensions =                                       
 200a350:	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 ||       
 200a354:	80 a0 e0 00 	cmp  %g3, 0                                    
 200a358:	02 80 00 06 	be  200a370 <_Thread_Handler_initialization+0x34><== NEVER TAKEN
 200a35c:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
 200a360:	c6 00 60 2c 	ld  [ %g1 + 0x2c ], %g3                        
 200a364:	80 a0 e0 00 	cmp  %g3, 0                                    
 200a368:	12 80 00 06 	bne  200a380 <_Thread_Handler_initialization+0x44>
 200a36c:	80 a0 a0 00 	cmp  %g2, 0                                    
       rtems_configuration_get_stack_free_hook() == NULL)             
    _Internal_error_Occurred(                                         
 200a370:	90 10 20 00 	clr  %o0                                       
 200a374:	92 10 20 01 	mov  1, %o1                                    
 200a378:	7f ff f9 e1 	call  2008afc <_Internal_error_Occurred>       
 200a37c:	94 10 20 0e 	mov  0xe, %o2                                  
      INTERNAL_ERROR_CORE,                                            
      true,                                                           
      INTERNAL_ERROR_BAD_STACK_HOOK                                   
    );                                                                
                                                                      
  if ( stack_allocate_init_hook != NULL )                             
 200a380:	22 80 00 05 	be,a   200a394 <_Thread_Handler_initialization+0x58>
 200a384:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
    (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
 200a388:	9f c0 80 00 	call  %g2                                      
 200a38c:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0	! 201d804 <_POSIX_Threads_Information+0x20>
                                                                      
  _Thread_Dispatch_necessary = false;                                 
 200a390:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 200a394:	82 10 62 f0 	or  %g1, 0x2f0, %g1	! 201daf0 <_Per_CPU_Information>
 200a398:	c0 28 60 0c 	clrb  [ %g1 + 0xc ]                            
  _Thread_Executing         = NULL;                                   
 200a39c:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
  _Thread_Heir              = NULL;                                   
 200a3a0:	c0 20 60 14 	clr  [ %g1 + 0x14 ]                            
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )        
  _Thread_Allocated_fp      = NULL;                                   
 200a3a4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a3a8:	c0 20 62 3c 	clr  [ %g1 + 0x23c ]	! 201d63c <_Thread_Allocated_fp>
#endif                                                                
                                                                      
  _Thread_Maximum_extensions = maximum_extensions;                    
 200a3ac:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a3b0:	f8 20 62 50 	st  %i4, [ %g1 + 0x250 ]	! 201d650 <_Thread_Maximum_extensions>
                                                                      
  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;                 
 200a3b4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a3b8:	fa 20 61 30 	st  %i5, [ %g1 + 0x130 ]	! 201d530 <_Thread_Ticks_per_timeslice>
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
 200a3bc:	82 10 20 08 	mov  8, %g1                                    
 200a3c0:	11 00 80 75 	sethi  %hi(0x201d400), %o0                     
 200a3c4:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 200a3c8:	90 12 22 c4 	or  %o0, 0x2c4, %o0                            
 200a3cc:	92 10 20 01 	mov  1, %o1                                    
 200a3d0:	94 10 20 01 	mov  1, %o2                                    
 200a3d4:	96 10 20 01 	mov  1, %o3                                    
 200a3d8:	98 10 21 68 	mov  0x168, %o4                                
 200a3dc:	7f ff fb 58 	call  200913c <_Objects_Initialize_information>
 200a3e0:	9a 10 20 00 	clr  %o5                                       
 200a3e4:	81 c7 e0 08 	ret                                            
 200a3e8:	81 e8 00 00 	restore                                        
                                                                      

0200a130 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) {
 200a130:	9d e3 bf 98 	save  %sp, -104, %sp                           
 200a134:	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;                             
 200a138:	c0 26 61 58 	clr  [ %i1 + 0x158 ]                           
 200a13c:	c0 26 61 5c 	clr  [ %i1 + 0x15c ]                           
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
 200a140:	c0 26 61 54 	clr  [ %i1 + 0x154 ]                           
  Thread_CPU_budget_algorithms          budget_algorithm,             
  Thread_CPU_budget_algorithm_callout   budget_callout,               
  uint32_t                              isr_level,                    
  Objects_Name                          name                          
)                                                                     
{                                                                     
 200a144:	e0 07 a0 60 	ld  [ %fp + 0x60 ], %l0                        
 200a148:	e2 00 40 00 	ld  [ %g1 ], %l1                               
    if ( !actual_stack_size || actual_stack_size < stack_size )       
      return false;                     /* stack allocation failed */ 
                                                                      
    stack = the_thread->Start.stack;                                  
  #else                                                               
    if ( !stack_area ) {                                              
 200a14c:	80 a6 a0 00 	cmp  %i2, 0                                    
 200a150:	12 80 00 0d 	bne  200a184 <_Thread_Initialize+0x54>         
 200a154:	e4 0f a0 5f 	ldub  [ %fp + 0x5f ], %l2                      
      actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
 200a158:	90 10 00 19 	mov  %i1, %o0                                  
 200a15c:	40 00 02 15 	call  200a9b0 <_Thread_Stack_Allocate>         
 200a160:	92 10 00 1b 	mov  %i3, %o1                                  
      if ( !actual_stack_size || actual_stack_size < stack_size )     
 200a164:	80 a2 00 1b 	cmp  %o0, %i3                                  
 200a168:	0a 80 00 71 	bcs  200a32c <_Thread_Initialize+0x1fc>        
 200a16c:	80 a2 20 00 	cmp  %o0, 0                                    
 200a170:	02 80 00 6f 	be  200a32c <_Thread_Initialize+0x1fc>         <== NEVER TAKEN
 200a174:	82 10 20 01 	mov  1, %g1                                    
        return false;                     /* stack allocation failed */
                                                                      
      stack = the_thread->Start.stack;                                
 200a178:	f4 06 60 c0 	ld  [ %i1 + 0xc0 ], %i2                        
      the_thread->Start.core_allocated_stack = true;                  
 200a17c:	10 80 00 04 	b  200a18c <_Thread_Initialize+0x5c>           
 200a180:	c2 2e 60 b0 	stb  %g1, [ %i1 + 0xb0 ]                       
    } else {                                                          
      stack = stack_area;                                             
      actual_stack_size = stack_size;                                 
      the_thread->Start.core_allocated_stack = false;                 
 200a184:	c0 2e 60 b0 	clrb  [ %i1 + 0xb0 ]                           
 200a188:	90 10 00 1b 	mov  %i3, %o0                                  
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
 200a18c:	f4 26 60 b8 	st  %i2, [ %i1 + 0xb8 ]                        
  the_stack->size = size;                                             
 200a190:	d0 26 60 b4 	st  %o0, [ %i1 + 0xb4 ]                        
                                                                      
  /*                                                                  
   *  Allocate the floating point area for this thread                
   */                                                                 
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    if ( is_fp ) {                                                    
 200a194:	80 a7 20 00 	cmp  %i4, 0                                    
 200a198:	02 80 00 07 	be  200a1b4 <_Thread_Initialize+0x84>          
 200a19c:	b6 10 20 00 	clr  %i3                                       
      fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );               
 200a1a0:	40 00 03 c2 	call  200b0a8 <_Workspace_Allocate>            
 200a1a4:	90 10 20 88 	mov  0x88, %o0                                 
      if ( !fp_area )                                                 
 200a1a8:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 200a1ac:	22 80 00 51 	be,a   200a2f0 <_Thread_Initialize+0x1c0>      
 200a1b0:	b8 10 20 00 	clr  %i4                                       
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
 200a1b4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a1b8:	d0 00 62 50 	ld  [ %g1 + 0x250 ], %o0	! 201d650 <_Thread_Maximum_extensions>
      fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );               
      if ( !fp_area )                                                 
        goto failed;                                                  
      fp_area = _Context_Fp_start( fp_area, 0 );                      
    }                                                                 
    the_thread->fp_context       = fp_area;                           
 200a1bc:	f6 26 61 50 	st  %i3, [ %i1 + 0x150 ]                       
    the_thread->Start.fp_context = fp_area;                           
 200a1c0:	f6 26 60 bc 	st  %i3, [ %i1 + 0xbc ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 200a1c4:	c0 26 60 50 	clr  [ %i1 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
 200a1c8:	c0 26 60 64 	clr  [ %i1 + 0x64 ]                            
  the_watchdog->id        = id;                                       
 200a1cc:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
  the_watchdog->user_data = user_data;                                
 200a1d0:	c0 26 60 6c 	clr  [ %i1 + 0x6c ]                            
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
 200a1d4:	80 a2 20 00 	cmp  %o0, 0                                    
 200a1d8:	02 80 00 08 	be  200a1f8 <_Thread_Initialize+0xc8>          
 200a1dc:	b8 10 20 00 	clr  %i4                                       
    extensions_area = _Workspace_Allocate(                            
 200a1e0:	90 02 20 01 	inc  %o0                                       
 200a1e4:	40 00 03 b1 	call  200b0a8 <_Workspace_Allocate>            
 200a1e8:	91 2a 20 02 	sll  %o0, 2, %o0                               
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
 200a1ec:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 200a1f0:	02 80 00 41 	be  200a2f4 <_Thread_Initialize+0x1c4>         
 200a1f4:	b4 10 20 00 	clr  %i2                                       
   * if they are linked to the thread. An extension user may          
   * create the extension long after tasks have been created          
   * so they cannot rely on the thread create user extension          
   * call.                                                            
   */                                                                 
  if ( the_thread->extensions ) {                                     
 200a1f8:	80 a7 20 00 	cmp  %i4, 0                                    
 200a1fc:	12 80 00 0a 	bne  200a224 <_Thread_Initialize+0xf4>         
 200a200:	f8 26 61 60 	st  %i4, [ %i1 + 0x160 ]                       
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
 200a204:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
 200a208:	e4 2e 60 9c 	stb  %l2, [ %i1 + 0x9c ]                       
  the_thread->Start.budget_algorithm = budget_algorithm;              
 200a20c:	e0 26 60 a0 	st  %l0, [ %i1 + 0xa0 ]                        
  the_thread->Start.budget_callout   = budget_callout;                
                                                                      
  switch ( budget_algorithm ) {                                       
 200a210:	80 a4 20 02 	cmp  %l0, 2                                    
 200a214:	12 80 00 12 	bne  200a25c <_Thread_Initialize+0x12c>        
 200a218:	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;    
 200a21c:	10 80 00 0e 	b  200a254 <_Thread_Initialize+0x124>          
 200a220:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
   * 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++ )              
 200a224:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a228:	c4 00 62 50 	ld  [ %g1 + 0x250 ], %g2	! 201d650 <_Thread_Maximum_extensions>
 200a22c:	10 80 00 05 	b  200a240 <_Thread_Initialize+0x110>          
 200a230:	82 10 20 00 	clr  %g1                                       
      the_thread->extensions[i] = NULL;                               
 200a234:	87 28 60 02 	sll  %g1, 2, %g3                               
   * 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++ )              
 200a238:	82 00 60 01 	inc  %g1                                       
      the_thread->extensions[i] = NULL;                               
 200a23c:	c0 21 00 03 	clr  [ %g4 + %g3 ]                             
   * 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++ )              
 200a240:	80 a0 40 02 	cmp  %g1, %g2                                  
 200a244:	28 bf ff fc 	bleu,a   200a234 <_Thread_Initialize+0x104>    
 200a248:	c8 06 61 60 	ld  [ %i1 + 0x160 ], %g4                       
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
  the_thread->Start.budget_algorithm = budget_algorithm;              
  the_thread->Start.budget_callout   = budget_callout;                
 200a24c:	10 bf ff ef 	b  200a208 <_Thread_Initialize+0xd8>           
 200a250:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
    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;    
 200a254:	c2 00 61 30 	ld  [ %g1 + 0x130 ], %g1                       
 200a258:	c2 26 60 74 	st  %g1, [ %i1 + 0x74 ]                        
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
 200a25c:	c2 07 a0 68 	ld  [ %fp + 0x68 ], %g1                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
 200a260:	a0 10 20 01 	mov  1, %l0                                    
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
 200a264:	c2 26 60 a8 	st  %g1, [ %i1 + 0xa8 ]                        
 */                                                                   
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.allocate( the_thread );                
 200a268:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 200a26c:	c2 00 61 cc 	ld  [ %g1 + 0x1cc ], %g1	! 201c9cc <_Scheduler+0x18>
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
 200a270:	e0 26 60 10 	st  %l0, [ %i1 + 0x10 ]                        
  the_thread->Wait.queue              = NULL;                         
 200a274:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            
  the_thread->resource_count          = 0;                            
 200a278:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  the_thread->real_priority           = priority;                     
 200a27c:	fa 26 60 18 	st  %i5, [ %i1 + 0x18 ]                        
  the_thread->Start.initial_priority  = priority;                     
 200a280:	fa 26 60 ac 	st  %i5, [ %i1 + 0xac ]                        
 200a284:	9f c0 40 00 	call  %g1                                      
 200a288:	90 10 00 19 	mov  %i1, %o0                                  
  sched =_Scheduler_Allocate( the_thread );                           
  if ( !sched )                                                       
 200a28c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 200a290:	02 80 00 19 	be  200a2f4 <_Thread_Initialize+0x1c4>         
 200a294:	90 10 00 19 	mov  %i1, %o0                                  
    goto failed;                                                      
  _Thread_Set_priority( the_thread, priority );                       
 200a298:	40 00 01 9e 	call  200a910 <_Thread_Set_priority>           
 200a29c:	92 10 00 1d 	mov  %i5, %o1                                  
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 200a2a0:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 200a2a4:	c2 16 60 0a 	lduh  [ %i1 + 0xa ], %g1                       
                                                                      
static inline void _Timestamp64_implementation_Set_to_zero(           
  Timestamp64_Control *_time                                          
)                                                                     
{                                                                     
  *_time = 0;                                                         
 200a2a8:	c0 26 60 80 	clr  [ %i1 + 0x80 ]                            
 200a2ac:	c0 26 60 84 	clr  [ %i1 + 0x84 ]                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 200a2b0:	83 28 60 02 	sll  %g1, 2, %g1                               
 200a2b4:	f2 20 80 01 	st  %i1, [ %g2 + %g1 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
 200a2b8:	e2 26 60 0c 	st  %l1, [ %i1 + 0xc ]                         
 * @{                                                                 
 */                                                                   
                                                                      
static inline bool _User_extensions_Thread_create( Thread_Control *created )
{                                                                     
  User_extensions_Thread_create_context ctx = { created, true };      
 200a2bc:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
 200a2c0:	e0 2f bf fc 	stb  %l0, [ %fp + -4 ]                         
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
 200a2c4:	90 07 bf f8 	add  %fp, -8, %o0                              
 200a2c8:	13 00 80 2a 	sethi  %hi(0x200a800), %o1                     
 200a2cc:	40 00 02 46 	call  200abe4 <_User_extensions_Iterate>       
 200a2d0:	92 12 62 c0 	or  %o1, 0x2c0, %o1	! 200aac0 <_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 )                                             
 200a2d4:	c2 0f bf fc 	ldub  [ %fp + -4 ], %g1                        
 200a2d8:	80 a0 60 00 	cmp  %g1, 0                                    
 200a2dc:	02 80 00 06 	be  200a2f4 <_Thread_Initialize+0x1c4>         
 200a2e0:	b0 10 20 01 	mov  1, %i0                                    
 200a2e4:	b0 0e 20 01 	and  %i0, 1, %i0                               
 200a2e8:	81 c7 e0 08 	ret                                            
 200a2ec:	81 e8 00 00 	restore                                        
  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;                                  
 200a2f0:	b4 10 20 00 	clr  %i2                                       
  extension_status = _User_extensions_Thread_create( the_thread );    
  if ( extension_status )                                             
    return true;                                                      
                                                                      
failed:                                                               
  _Workspace_Free( the_thread->libc_reent );                          
 200a2f4:	40 00 03 75 	call  200b0c8 <_Workspace_Free>                
 200a2f8:	d0 06 61 54 	ld  [ %i1 + 0x154 ], %o0                       
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    _Workspace_Free( the_thread->API_Extensions[i] );                 
 200a2fc:	40 00 03 73 	call  200b0c8 <_Workspace_Free>                
 200a300:	d0 06 61 58 	ld  [ %i1 + 0x158 ], %o0                       
 200a304:	40 00 03 71 	call  200b0c8 <_Workspace_Free>                
 200a308:	d0 06 61 5c 	ld  [ %i1 + 0x15c ], %o0                       
                                                                      
  _Workspace_Free( extensions_area );                                 
 200a30c:	40 00 03 6f 	call  200b0c8 <_Workspace_Free>                
 200a310:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    _Workspace_Free( fp_area );                                       
 200a314:	40 00 03 6d 	call  200b0c8 <_Workspace_Free>                
 200a318:	90 10 00 1b 	mov  %i3, %o0                                  
  #endif                                                              
                                                                      
   _Workspace_Free( sched );                                          
 200a31c:	40 00 03 6b 	call  200b0c8 <_Workspace_Free>                
 200a320:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
   _Thread_Stack_Free( the_thread );                                  
 200a324:	40 00 01 b3 	call  200a9f0 <_Thread_Stack_Free>             
 200a328:	90 10 00 19 	mov  %i1, %o0                                  
    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 */
 200a32c:	b0 10 20 00 	clr  %i0                                       
                                                                      
   _Workspace_Free( sched );                                          
                                                                      
   _Thread_Stack_Free( the_thread );                                  
  return false;                                                       
}                                                                     
 200a330:	b0 0e 20 01 	and  %i0, 1, %i0                               
 200a334:	81 c7 e0 08 	ret                                            
 200a338:	81 e8 00 00 	restore                                        
                                                                      

0200a9f0 <_Thread_Stack_Free>: #include <rtems/config.h> void _Thread_Stack_Free( Thread_Control *the_thread ) {
 200a9f0:	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 )                    
 200a9f4:	c4 0e 20 b0 	ldub  [ %i0 + 0xb0 ], %g2                      
                                                                      
void _Thread_Stack_Free(                                              
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  rtems_stack_free_hook stack_free_hook =                             
 200a9f8:	03 00 80 69 	sethi  %hi(0x201a400), %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 )                    
 200a9fc:	80 a0 a0 00 	cmp  %g2, 0                                    
 200aa00:	02 80 00 04 	be  200aa10 <_Thread_Stack_Free+0x20>          <== NEVER TAKEN
 200aa04:	c2 00 63 a4 	ld  [ %g1 + 0x3a4 ], %g1                       
   * 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 );         
 200aa08:	9f c0 40 00 	call  %g1                                      
 200aa0c:	d0 06 20 b8 	ld  [ %i0 + 0xb8 ], %o0                        
 200aa10:	81 c7 e0 08 	ret                                            
 200aa14:	81 e8 00 00 	restore                                        
                                                                      

0200a85c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
 200a85c:	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 )                                            
 200a860:	80 a6 20 00 	cmp  %i0, 0                                    
 200a864:	02 80 00 19 	be  200a8c8 <_Thread_queue_Requeue+0x6c>       <== NEVER TAKEN
 200a868:	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 ) {
 200a86c:	fa 06 20 34 	ld  [ %i0 + 0x34 ], %i5                        
 200a870:	80 a7 60 01 	cmp  %i5, 1                                    
 200a874:	12 80 00 15 	bne  200a8c8 <_Thread_queue_Requeue+0x6c>      <== NEVER TAKEN
 200a878:	01 00 00 00 	nop                                            
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
 200a87c:	7f ff df 52 	call  20025c4 <sparc_disable_interrupts>       
 200a880:	01 00 00 00 	nop                                            
 200a884:	b8 10 00 08 	mov  %o0, %i4                                  
 200a888:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
 200a88c:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
 200a890:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
 200a894:	80 88 80 01 	btst  %g2, %g1                                 
 200a898:	02 80 00 0a 	be  200a8c0 <_Thread_queue_Requeue+0x64>       <== NEVER TAKEN
 200a89c:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_queue_Enter_critical_section( tq );                     
      _Thread_queue_Extract_priority_helper( tq, the_thread, true );  
 200a8a0:	92 10 00 19 	mov  %i1, %o1                                  
 200a8a4:	94 10 20 01 	mov  1, %o2                                    
 200a8a8:	40 00 0c 81 	call  200daac <_Thread_queue_Extract_priority_helper>
 200a8ac:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
 200a8b0:	90 10 00 18 	mov  %i0, %o0                                  
 200a8b4:	92 10 00 19 	mov  %i1, %o1                                  
 200a8b8:	7f ff ff 50 	call  200a5f8 <_Thread_queue_Enqueue_priority> 
 200a8bc:	94 07 bf fc 	add  %fp, -4, %o2                              
    }                                                                 
    _ISR_Enable( level );                                             
 200a8c0:	7f ff df 45 	call  20025d4 <sparc_enable_interrupts>        
 200a8c4:	90 10 00 1c 	mov  %i4, %o0                                  
 200a8c8:	81 c7 e0 08 	ret                                            
 200a8cc:	81 e8 00 00 	restore                                        
                                                                      

0200a8d0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) {
 200a8d0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 200a8d4:	90 10 00 18 	mov  %i0, %o0                                  
 200a8d8:	7f ff fd ea 	call  200a080 <_Thread_Get>                    
 200a8dc:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 200a8e0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200a8e4:	80 a0 60 00 	cmp  %g1, 0                                    
 200a8e8:	12 80 00 08 	bne  200a908 <_Thread_queue_Timeout+0x38>      <== NEVER TAKEN
 200a8ec:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
 200a8f0:	40 00 0c a6 	call  200db88 <_Thread_queue_Process_timeout>  
 200a8f4:	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;                  
 200a8f8:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200a8fc:	c4 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g2	! 201d5d0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
 200a900:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
 200a904:	c4 20 61 d0 	st  %g2, [ %g1 + 0x1d0 ]                       
 200a908:	81 c7 e0 08 	ret                                            
 200a90c:	81 e8 00 00 	restore                                        
                                                                      

020189dc <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) {
 20189dc:	9d e3 bf 88 	save  %sp, -120, %sp                           
static void _Timer_server_Process_interval_watchdogs(                 
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;            
 20189e0:	27 00 80 f2 	sethi  %hi(0x203c800), %l3                     
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 20189e4:	a4 07 bf e8 	add  %fp, -24, %l2                             
 20189e8:	aa 07 bf ec 	add  %fp, -20, %l5                             
 20189ec:	b8 07 bf f4 	add  %fp, -12, %i4                             
 20189f0:	b2 07 bf f8 	add  %fp, -8, %i1                              
 20189f4:	ea 27 bf e8 	st  %l5, [ %fp + -24 ]                         
  head->previous = NULL;                                              
 20189f8:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
 20189fc:	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;                                                  
 2018a00:	f2 27 bf f4 	st  %i1, [ %fp + -12 ]                         
  head->previous = NULL;                                              
 2018a04:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  tail->previous = head;                                              
 2018a08:	f8 27 bf fc 	st  %i4, [ %fp + -4 ]                          
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
 2018a0c:	b4 06 20 30 	add  %i0, 0x30, %i2                            
static void _Timer_server_Process_tod_watchdogs(                      
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
 2018a10:	29 00 80 f2 	sethi  %hi(0x203c800), %l4                     
     /*                                                               
      *  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 ); 
 2018a14:	b6 06 20 68 	add  %i0, 0x68, %i3                            
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
 2018a18:	a2 06 20 08 	add  %i0, 8, %l1                               
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
 2018a1c:	a0 06 20 40 	add  %i0, 0x40, %l0                            
{                                                                     
  /*                                                                  
   *  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;                                    
 2018a20:	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;            
 2018a24:	c2 04 e2 9c 	ld  [ %l3 + 0x29c ], %g1                       
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
 2018a28:	d2 06 20 3c 	ld  [ %i0 + 0x3c ], %o1                        
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
 2018a2c:	90 10 00 1a 	mov  %i2, %o0                                  
 2018a30:	92 20 40 09 	sub  %g1, %o1, %o1                             
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
 2018a34:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
 2018a38:	40 00 11 ce 	call  201d170 <_Watchdog_Adjust_to_chain>      
 2018a3c:	94 10 00 1c 	mov  %i4, %o2                                  
 2018a40:	d0 1d 20 f8 	ldd  [ %l4 + 0xf8 ], %o0                       
 2018a44:	94 10 20 00 	clr  %o2                                       
 2018a48:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2018a4c:	40 00 4f 4b 	call  202c778 <__divdi3>                       
 2018a50:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  Timer_server_Watchdogs *watchdogs,                                  
  Chain_Control *fire_chain                                           
)                                                                     
{                                                                     
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;         
 2018a54:	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 ) {                                   
 2018a58:	80 a2 40 0a 	cmp  %o1, %o2                                  
 2018a5c:	08 80 00 07 	bleu  2018a78 <_Timer_server_Body+0x9c>        
 2018a60:	ba 10 00 09 	mov  %o1, %i5                                  
    /*                                                                
     *  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 );
 2018a64:	92 22 40 0a 	sub  %o1, %o2, %o1                             
 2018a68:	90 10 00 1b 	mov  %i3, %o0                                  
 2018a6c:	40 00 11 c1 	call  201d170 <_Watchdog_Adjust_to_chain>      
 2018a70:	94 10 00 1c 	mov  %i4, %o2                                  
 2018a74:	30 80 00 06 	b,a   2018a8c <_Timer_server_Body+0xb0>        
                                                                      
  } else if ( snapshot < last_snapshot ) {                            
 2018a78:	1a 80 00 05 	bcc  2018a8c <_Timer_server_Body+0xb0>         
 2018a7c:	90 10 00 1b 	mov  %i3, %o0                                  
     /*                                                               
      *  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 ); 
 2018a80:	92 10 20 01 	mov  1, %o1                                    
 2018a84:	40 00 11 93 	call  201d0d0 <_Watchdog_Adjust>               
 2018a88:	94 22 80 1d 	sub  %o2, %i5, %o2                             
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
 2018a8c:	fa 26 20 74 	st  %i5, [ %i0 + 0x74 ]                        
}                                                                     
                                                                      
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{                                                                     
  while ( true ) {                                                    
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
 2018a90:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
 2018a94:	40 00 02 f4 	call  2019664 <_Chain_Get>                     
 2018a98:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
 2018a9c:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2018aa0:	02 80 00 0c 	be  2018ad0 <_Timer_server_Body+0xf4>          
 2018aa4:	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 ) {                 
 2018aa8:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        
 2018aac:	80 a0 60 01 	cmp  %g1, 1                                    
 2018ab0:	02 80 00 05 	be  2018ac4 <_Timer_server_Body+0xe8>          
 2018ab4:	90 10 00 1a 	mov  %i2, %o0                                  
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
 2018ab8:	80 a0 60 03 	cmp  %g1, 3                                    
 2018abc:	12 bf ff f5 	bne  2018a90 <_Timer_server_Body+0xb4>         <== NEVER TAKEN
 2018ac0:	90 10 00 1b 	mov  %i3, %o0                                  
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
 2018ac4:	40 00 11 d5 	call  201d218 <_Watchdog_Insert>               
 2018ac8:	92 02 60 10 	add  %o1, 0x10, %o1                            
 2018acc:	30 bf ff f1 	b,a   2018a90 <_Timer_server_Body+0xb4>        
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.                                                    
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
 2018ad0:	7f ff df 18 	call  2010730 <sparc_disable_interrupts>       
 2018ad4:	01 00 00 00 	nop                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
 2018ad8:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
 2018adc:	80 a0 40 15 	cmp  %g1, %l5                                  
 2018ae0:	12 80 00 0a 	bne  2018b08 <_Timer_server_Body+0x12c>        <== NEVER TAKEN
 2018ae4:	01 00 00 00 	nop                                            
      ts->insert_chain = NULL;                                        
 2018ae8:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
      _ISR_Enable( level );                                           
 2018aec:	7f ff df 15 	call  2010740 <sparc_enable_interrupts>        
 2018af0:	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 ) ) {                          
 2018af4:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
 2018af8:	80 a0 40 19 	cmp  %g1, %i1                                  
 2018afc:	12 80 00 06 	bne  2018b14 <_Timer_server_Body+0x138>        
 2018b00:	01 00 00 00 	nop                                            
 2018b04:	30 80 00 18 	b,a   2018b64 <_Timer_server_Body+0x188>       
      ts->insert_chain = NULL;                                        
      _ISR_Enable( level );                                           
                                                                      
      break;                                                          
    } else {                                                          
      _ISR_Enable( level );                                           
 2018b08:	7f ff df 0e 	call  2010740 <sparc_enable_interrupts>        <== NOT EXECUTED
 2018b0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2018b10:	30 bf ff c5 	b,a   2018a24 <_Timer_server_Body+0x48>        <== NOT EXECUTED
                                                                      
        /*                                                            
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.     
         */                                                           
        _ISR_Disable( level );                                        
 2018b14:	7f ff df 07 	call  2010730 <sparc_disable_interrupts>       
 2018b18:	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;                    
 2018b1c:	fa 07 bf f4 	ld  [ %fp + -12 ], %i5                         
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(              
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  if ( !_Chain_Is_empty(the_chain))                                   
 2018b20:	80 a7 40 19 	cmp  %i5, %i1                                  
 2018b24:	02 80 00 0d 	be  2018b58 <_Timer_server_Body+0x17c>         
 2018b28:	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;                            
 2018b2c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
                                                                      
  head->next = new_first;                                             
  new_first->previous = head;                                         
 2018b30:	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;                                             
 2018b34:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
 2018b38:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
          _ISR_Enable( level );                                       
 2018b3c:	7f ff df 01 	call  2010740 <sparc_enable_interrupts>        
 2018b40:	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 );    
 2018b44:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 2018b48:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
 2018b4c:	9f c0 40 00 	call  %g1                                      
 2018b50:	d2 07 60 24 	ld  [ %i5 + 0x24 ], %o1                        
      }                                                               
 2018b54:	30 bf ff f0 	b,a   2018b14 <_Timer_server_Body+0x138>       
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {                                     
          watchdog->state = WATCHDOG_INACTIVE;                        
          _ISR_Enable( level );                                       
        } else {                                                      
          _ISR_Enable( level );                                       
 2018b58:	7f ff de fa 	call  2010740 <sparc_enable_interrupts>        
 2018b5c:	01 00 00 00 	nop                                            
 2018b60:	30 bf ff b0 	b,a   2018a20 <_Timer_server_Body+0x44>        
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
 2018b64:	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;                  
 2018b68:	03 00 80 f2 	sethi  %hi(0x203c800), %g1                     
 2018b6c:	c4 00 61 b0 	ld  [ %g1 + 0x1b0 ], %g2	! 203c9b0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 2018b70:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2018b74:	c4 20 61 b0 	st  %g2, [ %g1 + 0x1b0 ]                       
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
 2018b78:	d0 06 00 00 	ld  [ %i0 ], %o0                               
 2018b7c:	40 00 10 68 	call  201cd1c <_Thread_Set_state>              
 2018b80:	92 10 20 08 	mov  8, %o1                                    
        _Timer_server_Reset_interval_system_watchdog( ts );           
 2018b84:	7f ff ff 6e 	call  201893c <_Timer_server_Reset_interval_system_watchdog>
 2018b88:	90 10 00 18 	mov  %i0, %o0                                  
        _Timer_server_Reset_tod_system_watchdog( ts );                
 2018b8c:	7f ff ff 80 	call  201898c <_Timer_server_Reset_tod_system_watchdog>
 2018b90:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_Enable_dispatch();                                      
 2018b94:	40 00 0e 05 	call  201c3a8 <_Thread_Enable_dispatch>        
 2018b98:	01 00 00 00 	nop                                            
                                                                      
      ts->active = true;                                              
 2018b9c:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
 2018ba0:	90 10 00 11 	mov  %l1, %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;                                              
 2018ba4:	c2 2e 20 7c 	stb  %g1, [ %i0 + 0x7c ]                       
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
 2018ba8:	40 00 11 f4 	call  201d378 <_Watchdog_Remove>               
 2018bac:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
 2018bb0:	40 00 11 f2 	call  201d378 <_Watchdog_Remove>               
 2018bb4:	90 10 00 10 	mov  %l0, %o0                                  
 2018bb8:	30 bf ff 9a 	b,a   2018a20 <_Timer_server_Body+0x44>        
                                                                      

02018bbc <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) {
 2018bbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( ts->insert_chain == NULL ) {                                   
 2018bc0:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
 2018bc4:	80 a0 60 00 	cmp  %g1, 0                                    
 2018bc8:	12 80 00 51 	bne  2018d0c <_Timer_server_Schedule_operation_method+0x150>
 2018bcc:	ba 10 00 19 	mov  %i1, %i5                                  
   *                                                                  
   * 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;                  
 2018bd0:	03 00 80 f2 	sethi  %hi(0x203c800), %g1                     
 2018bd4:	c4 00 61 b0 	ld  [ %g1 + 0x1b0 ], %g2	! 203c9b0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 2018bd8:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2018bdc:	c4 20 61 b0 	st  %g2, [ %g1 + 0x1b0 ]                       
   *  being inserted.  This could result in an integer overflow.      
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
 2018be0:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
 2018be4:	80 a0 60 01 	cmp  %g1, 1                                    
 2018be8:	12 80 00 1f 	bne  2018c64 <_Timer_server_Schedule_operation_method+0xa8>
 2018bec:	80 a0 60 03 	cmp  %g1, 3                                    
    /*                                                                
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
 2018bf0:	7f ff de d0 	call  2010730 <sparc_disable_interrupts>       
 2018bf4:	01 00 00 00 	nop                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
 2018bf8:	03 00 80 f2 	sethi  %hi(0x203c800), %g1                     
 2018bfc:	c4 00 62 9c 	ld  [ %g1 + 0x29c ], %g2	! 203ca9c <_Watchdog_Ticks_since_boot>
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 2018c00:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
 2018c04:	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 );                            
 2018c08:	86 06 20 34 	add  %i0, 0x34, %g3                            
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
 2018c0c:	80 a0 40 03 	cmp  %g1, %g3                                  
 2018c10:	02 80 00 08 	be  2018c30 <_Timer_server_Schedule_operation_method+0x74>
 2018c14:	88 20 80 04 	sub  %g2, %g4, %g4                             
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
 2018c18:	f8 00 60 10 	ld  [ %g1 + 0x10 ], %i4                        
      if (delta_interval > delta) {                                   
 2018c1c:	80 a7 00 04 	cmp  %i4, %g4                                  
 2018c20:	08 80 00 03 	bleu  2018c2c <_Timer_server_Schedule_operation_method+0x70>
 2018c24:	86 10 20 00 	clr  %g3                                       
        delta_interval -= delta;                                      
 2018c28:	86 27 00 04 	sub  %i4, %g4, %g3                             
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
 2018c2c:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
 2018c30:	c4 26 20 3c 	st  %g2, [ %i0 + 0x3c ]                        
    _ISR_Enable( level );                                             
 2018c34:	7f ff de c3 	call  2010740 <sparc_enable_interrupts>        
 2018c38:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
 2018c3c:	90 06 20 30 	add  %i0, 0x30, %o0                            
 2018c40:	40 00 11 76 	call  201d218 <_Watchdog_Insert>               
 2018c44:	92 07 60 10 	add  %i5, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
 2018c48:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
 2018c4c:	80 a0 60 00 	cmp  %g1, 0                                    
 2018c50:	12 80 00 2d 	bne  2018d04 <_Timer_server_Schedule_operation_method+0x148>
 2018c54:	01 00 00 00 	nop                                            
      _Timer_server_Reset_interval_system_watchdog( ts );             
 2018c58:	7f ff ff 39 	call  201893c <_Timer_server_Reset_interval_system_watchdog>
 2018c5c:	90 10 00 18 	mov  %i0, %o0                                  
 2018c60:	30 80 00 29 	b,a   2018d04 <_Timer_server_Schedule_operation_method+0x148>
    }                                                                 
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {       
 2018c64:	12 80 00 28 	bne  2018d04 <_Timer_server_Schedule_operation_method+0x148>
 2018c68:	01 00 00 00 	nop                                            
    /*                                                                
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.                               
     */                                                               
    _ISR_Disable( level );                                            
 2018c6c:	7f ff de b1 	call  2010730 <sparc_disable_interrupts>       
 2018c70:	01 00 00 00 	nop                                            
 2018c74:	b8 10 00 08 	mov  %o0, %i4                                  
 2018c78:	03 00 80 f2 	sethi  %hi(0x203c800), %g1                     
 2018c7c:	d0 18 60 f8 	ldd  [ %g1 + 0xf8 ], %o0	! 203c8f8 <_TOD>      
 2018c80:	94 10 20 00 	clr  %o2                                       
 2018c84:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2018c88:	40 00 4e bc 	call  202c778 <__divdi3>                       
 2018c8c:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 2018c90:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
 2018c94:	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 );                            
 2018c98:	86 06 20 6c 	add  %i0, 0x6c, %g3                            
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
 2018c9c:	80 a0 40 03 	cmp  %g1, %g3                                  
 2018ca0:	02 80 00 0d 	be  2018cd4 <_Timer_server_Schedule_operation_method+0x118>
 2018ca4:	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 ) {                               
 2018ca8:	08 80 00 08 	bleu  2018cc8 <_Timer_server_Schedule_operation_method+0x10c>
 2018cac:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
 2018cb0:	88 22 40 02 	sub  %o1, %g2, %g4                             
        if (delta_interval > delta) {                                 
 2018cb4:	80 a0 c0 04 	cmp  %g3, %g4                                  
 2018cb8:	08 80 00 06 	bleu  2018cd0 <_Timer_server_Schedule_operation_method+0x114><== NEVER TAKEN
 2018cbc:	84 10 20 00 	clr  %g2                                       
          delta_interval -= delta;                                    
 2018cc0:	10 80 00 04 	b  2018cd0 <_Timer_server_Schedule_operation_method+0x114>
 2018cc4:	84 20 c0 04 	sub  %g3, %g4, %g2                             
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
 2018cc8:	84 00 c0 02 	add  %g3, %g2, %g2                             
        delta_interval += delta;                                      
 2018ccc:	84 20 80 09 	sub  %g2, %o1, %g2                             
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
 2018cd0:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
 2018cd4:	d2 26 20 74 	st  %o1, [ %i0 + 0x74 ]                        
    _ISR_Enable( level );                                             
 2018cd8:	7f ff de 9a 	call  2010740 <sparc_enable_interrupts>        
 2018cdc:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
 2018ce0:	90 06 20 68 	add  %i0, 0x68, %o0                            
 2018ce4:	40 00 11 4d 	call  201d218 <_Watchdog_Insert>               
 2018ce8:	92 07 60 10 	add  %i5, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
 2018cec:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
 2018cf0:	80 a0 60 00 	cmp  %g1, 0                                    
 2018cf4:	12 80 00 04 	bne  2018d04 <_Timer_server_Schedule_operation_method+0x148>
 2018cf8:	01 00 00 00 	nop                                            
      _Timer_server_Reset_tod_system_watchdog( ts );                  
 2018cfc:	7f ff ff 24 	call  201898c <_Timer_server_Reset_tod_system_watchdog>
 2018d00:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
 2018d04:	40 00 0d a9 	call  201c3a8 <_Thread_Enable_dispatch>        
 2018d08:	81 e8 00 00 	restore                                        
     *  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 );           
 2018d0c:	f0 06 20 78 	ld  [ %i0 + 0x78 ], %i0                        
 2018d10:	40 00 02 49 	call  2019634 <_Chain_Append>                  
 2018d14:	81 e8 00 00 	restore                                        
                                                                      

0200c3b4 <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) {
 200c3b4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Timestamp64_Control answer;                                         
                                                                      
  if ( *_rhs == 0 ) {                                                 
 200c3b8:	d4 1e 40 00 	ldd  [ %i1 ], %o2                              
 200c3bc:	80 92 80 0b 	orcc  %o2, %o3, %g0                            
 200c3c0:	32 80 00 06 	bne,a   200c3d8 <_Timestamp64_Divide+0x24>     <== ALWAYS TAKEN
 200c3c4:	d8 1e 00 00 	ldd  [ %i0 ], %o4                              
    *_ival_percentage = 0;                                            
 200c3c8:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
    *_fval_percentage = 0;                                            
 200c3cc:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
    return;                                                           
 200c3d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200c3d4:	81 e8 00 00 	restore                                        <== 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;                                  
 200c3d8:	83 2b 20 02 	sll  %o4, 2, %g1                               
 200c3dc:	87 2b 60 02 	sll  %o5, 2, %g3                               
 200c3e0:	89 33 60 1e 	srl  %o5, 0x1e, %g4                            
 200c3e4:	bb 28 e0 05 	sll  %g3, 5, %i5                               
 200c3e8:	84 11 00 01 	or  %g4, %g1, %g2                              
 200c3ec:	83 30 e0 1b 	srl  %g3, 0x1b, %g1                            
 200c3f0:	b9 28 a0 05 	sll  %g2, 5, %i4                               
 200c3f4:	86 a7 40 03 	subcc  %i5, %g3, %g3                           
 200c3f8:	b8 10 40 1c 	or  %g1, %i4, %i4                              
 200c3fc:	84 67 00 02 	subx  %i4, %g2, %g2                            
 200c400:	b2 80 c0 0d 	addcc  %g3, %o5, %i1                           
 200c404:	b0 40 80 0c 	addx  %g2, %o4, %i0                            
 200c408:	83 36 60 1e 	srl  %i1, 0x1e, %g1                            
 200c40c:	87 2e 60 02 	sll  %i1, 2, %g3                               
 200c410:	85 2e 20 02 	sll  %i0, 2, %g2                               
 200c414:	84 10 40 02 	or  %g1, %g2, %g2                              
 200c418:	ba 86 40 03 	addcc  %i1, %g3, %i5                           
 200c41c:	b8 46 00 02 	addx  %i0, %g2, %i4                            
 200c420:	83 37 60 1e 	srl  %i5, 0x1e, %g1                            
 200c424:	87 2f 60 02 	sll  %i5, 2, %g3                               
 200c428:	85 2f 20 02 	sll  %i4, 2, %g2                               
 200c42c:	84 10 40 02 	or  %g1, %g2, %g2                              
 200c430:	92 87 40 03 	addcc  %i5, %g3, %o1                           
 200c434:	90 47 00 02 	addx  %i4, %g2, %o0                            
 200c438:	87 32 60 1b 	srl  %o1, 0x1b, %g3                            
 200c43c:	85 2a 20 05 	sll  %o0, 5, %g2                               
 200c440:	83 2a 60 05 	sll  %o1, 5, %g1                               
 200c444:	90 10 c0 02 	or  %g3, %g2, %o0                              
 200c448:	40 00 39 f4 	call  201ac18 <__divdi3>                       
 200c44c:	92 10 00 01 	mov  %g1, %o1                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
 200c450:	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;                                  
 200c454:	b8 10 00 08 	mov  %o0, %i4                                  
 200c458:	ba 10 00 09 	mov  %o1, %i5                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
 200c45c:	40 00 39 ef 	call  201ac18 <__divdi3>                       
 200c460:	96 10 23 e8 	mov  0x3e8, %o3                                
  *_fval_percentage = answer % 1000;                                  
 200c464:	90 10 00 1c 	mov  %i4, %o0                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (*_lhs * 100000) / *_rhs;                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
 200c468:	d2 26 80 00 	st  %o1, [ %i2 ]                               
  *_fval_percentage = answer % 1000;                                  
 200c46c:	94 10 20 00 	clr  %o2                                       
 200c470:	92 10 00 1d 	mov  %i5, %o1                                  
 200c474:	40 00 3a d4 	call  201afc4 <__moddi3>                       
 200c478:	96 10 23 e8 	mov  0x3e8, %o3                                
 200c47c:	d2 26 c0 00 	st  %o1, [ %i3 ]                               
 200c480:	81 c7 e0 08 	ret                                            
 200c484:	81 e8 00 00 	restore                                        
                                                                      

0200aca4 <_User_extensions_Handler_initialization>: } } void _User_extensions_Handler_initialization(void) {
 200aca4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uint32_t number_of_initial_extensions =                             
 200aca8:	03 00 80 69 	sethi  %hi(0x201a400), %g1                     
 200acac:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 201a7b8 <Configuration+0x40>
    rtems_configuration_get_number_of_initial_extensions();           
                                                                      
  if ( number_of_initial_extensions > 0 ) {                           
 200acb0:	80 a0 60 00 	cmp  %g1, 0                                    
 200acb4:	02 80 00 0a 	be  200acdc <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
 200acb8:	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 )              
 200acbc:	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 =
 200acc0:	40 00 01 08 	call  200b0e0 <_Workspace_Allocate_or_fatal_error>
 200acc4:	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 );
 200acc8:	13 00 80 2b 	sethi  %hi(0x200ac00), %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 };
 200accc:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
    _User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
 200acd0:	92 12 60 60 	or  %o1, 0x60, %o1                             
 200acd4:	7f ff ff c4 	call  200abe4 <_User_extensions_Iterate>       
 200acd8:	90 07 bf fc 	add  %fp, -4, %o0                              
 200acdc:	81 c7 e0 08 	ret                                            
 200ace0:	81 e8 00 00 	restore                                        
                                                                      

0200c6ec <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) {
 200c6ec:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
 200c6f0:	7f ff db 47 	call  200340c <sparc_disable_interrupts>       
 200c6f4:	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;                    
 200c6f8:	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 );                            
 200c6fc:	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 ) ) {                                 
 200c700:	80 a0 40 1c 	cmp  %g1, %i4                                  
 200c704:	02 80 00 20 	be  200c784 <_Watchdog_Adjust+0x98>            
 200c708:	80 a6 60 00 	cmp  %i1, 0                                    
    switch ( direction ) {                                            
 200c70c:	02 80 00 1b 	be  200c778 <_Watchdog_Adjust+0x8c>            
 200c710:	b6 10 20 01 	mov  1, %i3                                    
 200c714:	80 a6 60 01 	cmp  %i1, 1                                    
 200c718:	12 80 00 1b 	bne  200c784 <_Watchdog_Adjust+0x98>           <== NEVER TAKEN
 200c71c:	01 00 00 00 	nop                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
 200c720:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 200c724:	10 80 00 07 	b  200c740 <_Watchdog_Adjust+0x54>             
 200c728:	b4 00 80 1a 	add  %g2, %i2, %i2                             
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
          if ( units < _Watchdog_First( header )->delta_interval ) {  
 200c72c:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 200c730:	80 a6 80 02 	cmp  %i2, %g2                                  
 200c734:	3a 80 00 05 	bcc,a   200c748 <_Watchdog_Adjust+0x5c>        
 200c738:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
            _Watchdog_First( header )->delta_interval -= units;       
 200c73c:	b4 20 80 1a 	sub  %g2, %i2, %i2                             
            break;                                                    
 200c740:	10 80 00 11 	b  200c784 <_Watchdog_Adjust+0x98>             
 200c744:	f4 20 60 10 	st  %i2, [ %g1 + 0x10 ]                        
          } else {                                                    
            units -= _Watchdog_First( header )->delta_interval;       
 200c748:	b4 26 80 02 	sub  %i2, %g2, %i2                             
            _Watchdog_First( header )->delta_interval = 1;            
                                                                      
            _ISR_Enable( level );                                     
 200c74c:	7f ff db 34 	call  200341c <sparc_enable_interrupts>        
 200c750:	01 00 00 00 	nop                                            
                                                                      
            _Watchdog_Tickle( header );                               
 200c754:	40 00 00 90 	call  200c994 <_Watchdog_Tickle>               
 200c758:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
            _ISR_Disable( level );                                    
 200c75c:	7f ff db 2c 	call  200340c <sparc_disable_interrupts>       
 200c760:	01 00 00 00 	nop                                            
                                                                      
            if ( _Chain_Is_empty( header ) )                          
 200c764:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 200c768:	80 a0 40 1c 	cmp  %g1, %i4                                  
 200c76c:	12 80 00 04 	bne  200c77c <_Watchdog_Adjust+0x90>           
 200c770:	80 a6 a0 00 	cmp  %i2, 0                                    
 200c774:	30 80 00 04 	b,a   200c784 <_Watchdog_Adjust+0x98>          
    switch ( direction ) {                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
 200c778:	80 a6 a0 00 	cmp  %i2, 0                                    
 200c77c:	32 bf ff ec 	bne,a   200c72c <_Watchdog_Adjust+0x40>        <== ALWAYS TAKEN
 200c780:	c2 06 00 00 	ld  [ %i0 ], %g1                               
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
 200c784:	7f ff db 26 	call  200341c <sparc_enable_interrupts>        
 200c788:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0200ae44 <_Watchdog_Remove>: #include <rtems/score/watchdog.h> Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) {
 200ae44:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
 200ae48:	7f ff dd df 	call  20025c4 <sparc_disable_interrupts>       
 200ae4c:	ba 10 00 18 	mov  %i0, %i5                                  
  previous_state = the_watchdog->state;                               
 200ae50:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  switch ( previous_state ) {                                         
 200ae54:	80 a6 20 01 	cmp  %i0, 1                                    
 200ae58:	22 80 00 1e 	be,a   200aed0 <_Watchdog_Remove+0x8c>         
 200ae5c:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
 200ae60:	0a 80 00 1d 	bcs  200aed4 <_Watchdog_Remove+0x90>           
 200ae64:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200ae68:	80 a6 20 03 	cmp  %i0, 3                                    
 200ae6c:	18 80 00 1a 	bgu  200aed4 <_Watchdog_Remove+0x90>           <== NEVER TAKEN
 200ae70:	01 00 00 00 	nop                                            
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(                
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  return ( (Watchdog_Control *) the_watchdog->Node.next );            
 200ae74:	10 80 00 02 	b  200ae7c <_Watchdog_Remove+0x38>             
 200ae78:	c2 07 40 00 	ld  [ %i5 ], %g1                               
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
 200ae7c:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
 200ae80:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 200ae84:	80 a0 a0 00 	cmp  %g2, 0                                    
 200ae88:	02 80 00 07 	be  200aea4 <_Watchdog_Remove+0x60>            
 200ae8c:	05 00 80 75 	sethi  %hi(0x201d400), %g2                     
        next_watchdog->delta_interval += the_watchdog->delta_interval;
 200ae90:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
 200ae94:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
 200ae98:	84 00 c0 02 	add  %g3, %g2, %g2                             
 200ae9c:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
      if ( _Watchdog_Sync_count )                                     
 200aea0:	05 00 80 75 	sethi  %hi(0x201d400), %g2                     
 200aea4:	c4 00 a2 b8 	ld  [ %g2 + 0x2b8 ], %g2	! 201d6b8 <_Watchdog_Sync_count>
 200aea8:	80 a0 a0 00 	cmp  %g2, 0                                    
 200aeac:	22 80 00 07 	be,a   200aec8 <_Watchdog_Remove+0x84>         
 200aeb0:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
        _Watchdog_Sync_level = _ISR_Nest_level;                       
 200aeb4:	05 00 80 76 	sethi  %hi(0x201d800), %g2                     
 200aeb8:	c6 00 a2 f8 	ld  [ %g2 + 0x2f8 ], %g3	! 201daf8 <_Per_CPU_Information+0x8>
 200aebc:	05 00 80 75 	sethi  %hi(0x201d400), %g2                     
 200aec0:	c6 20 a2 58 	st  %g3, [ %g2 + 0x258 ]	! 201d658 <_Watchdog_Sync_level>
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200aec4:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
  next->previous = previous;                                          
 200aec8:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  previous->next = next;                                              
 200aecc:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
 200aed0:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200aed4:	c2 00 62 bc 	ld  [ %g1 + 0x2bc ], %g1	! 201d6bc <_Watchdog_Ticks_since_boot>
 200aed8:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
 200aedc:	7f ff dd be 	call  20025d4 <sparc_enable_interrupts>        
 200aee0:	01 00 00 00 	nop                                            
  return( previous_state );                                           
}                                                                     
 200aee4:	81 c7 e0 08 	ret                                            
 200aee8:	81 e8 00 00 	restore                                        
                                                                      

0200c098 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) {
 200c098:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
 200c09c:	7f ff db b9 	call  2002f80 <sparc_disable_interrupts>       
 200c0a0:	b8 10 00 18 	mov  %i0, %i4                                  
 200c0a4:	b0 10 00 08 	mov  %o0, %i0                                  
    printk( "Watchdog Chain: %s %p\n", name, header );                
 200c0a8:	11 00 80 75 	sethi  %hi(0x201d400), %o0                     
 200c0ac:	94 10 00 19 	mov  %i1, %o2                                  
 200c0b0:	90 12 20 68 	or  %o0, 0x68, %o0                             
 200c0b4:	7f ff e3 3c 	call  2004da4 <printk>                         
 200c0b8:	92 10 00 1c 	mov  %i4, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 200c0bc:	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 );                            
 200c0c0:	b2 06 60 04 	add  %i1, 4, %i1                               
    if ( !_Chain_Is_empty( header ) ) {                               
 200c0c4:	80 a7 40 19 	cmp  %i5, %i1                                  
 200c0c8:	12 80 00 04 	bne  200c0d8 <_Watchdog_Report_chain+0x40>     
 200c0cc:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
 200c0d0:	10 80 00 0d 	b  200c104 <_Watchdog_Report_chain+0x6c>       
 200c0d4:	11 00 80 75 	sethi  %hi(0x201d400), %o0                     
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
 200c0d8:	40 00 00 0f 	call  200c114 <_Watchdog_Report>               
 200c0dc:	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 )                                       
 200c0e0:	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 ) ;                           
 200c0e4:	80 a7 40 19 	cmp  %i5, %i1                                  
 200c0e8:	12 bf ff fc 	bne  200c0d8 <_Watchdog_Report_chain+0x40>     <== NEVER TAKEN
 200c0ec:	92 10 00 1d 	mov  %i5, %o1                                  
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
 200c0f0:	11 00 80 75 	sethi  %hi(0x201d400), %o0                     
 200c0f4:	92 10 00 1c 	mov  %i4, %o1                                  
 200c0f8:	7f ff e3 2b 	call  2004da4 <printk>                         
 200c0fc:	90 12 20 80 	or  %o0, 0x80, %o0                             
 200c100:	30 80 00 03 	b,a   200c10c <_Watchdog_Report_chain+0x74>    
    } else {                                                          
      printk( "Chain is empty\n" );                                   
 200c104:	7f ff e3 28 	call  2004da4 <printk>                         
 200c108:	90 12 20 90 	or  %o0, 0x90, %o0                             
    }                                                                 
  _ISR_Enable( level );                                               
 200c10c:	7f ff db a1 	call  2002f90 <sparc_enable_interrupts>        
 200c110:	81 e8 00 00 	restore                                        
                                                                      

0200aeec <_Watchdog_Tickle>: #include <rtems/score/watchdog.h> void _Watchdog_Tickle( Chain_Control *header ) {
 200aeec:	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 );                                              
 200aef0:	7f ff dd b5 	call  20025c4 <sparc_disable_interrupts>       
 200aef4:	b8 10 00 18 	mov  %i0, %i4                                  
 200aef8:	b0 10 00 08 	mov  %o0, %i0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 200aefc:	fa 07 00 00 	ld  [ %i4 ], %i5                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 200af00:	b6 07 20 04 	add  %i4, 4, %i3                               
                                                                      
  if ( _Chain_Is_empty( header ) )                                    
 200af04:	80 a7 40 1b 	cmp  %i5, %i3                                  
 200af08:	02 80 00 1f 	be  200af84 <_Watchdog_Tickle+0x98>            
 200af0c:	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) {                            
 200af10:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200af14:	80 a0 60 00 	cmp  %g1, 0                                    
 200af18:	02 80 00 06 	be  200af30 <_Watchdog_Tickle+0x44>            <== NEVER TAKEN
 200af1c:	82 00 7f ff 	add  %g1, -1, %g1                              
    the_watchdog->delta_interval--;                                   
 200af20:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
    if ( the_watchdog->delta_interval != 0 )                          
 200af24:	80 a0 60 00 	cmp  %g1, 0                                    
 200af28:	12 80 00 17 	bne  200af84 <_Watchdog_Tickle+0x98>           
 200af2c:	01 00 00 00 	nop                                            
      goto leave;                                                     
  }                                                                   
                                                                      
  do {                                                                
     watchdog_state = _Watchdog_Remove( the_watchdog );               
 200af30:	7f ff ff c5 	call  200ae44 <_Watchdog_Remove>               
 200af34:	90 10 00 1d 	mov  %i5, %o0                                  
 200af38:	b4 10 00 08 	mov  %o0, %i2                                  
                                                                      
     _ISR_Enable( level );                                            
 200af3c:	7f ff dd a6 	call  20025d4 <sparc_enable_interrupts>        
 200af40:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
     switch( watchdog_state ) {                                       
 200af44:	80 a6 a0 02 	cmp  %i2, 2                                    
 200af48:	12 80 00 06 	bne  200af60 <_Watchdog_Tickle+0x74>           
 200af4c:	01 00 00 00 	nop                                            
       case WATCHDOG_ACTIVE:                                          
         (*the_watchdog->routine)(                                    
 200af50:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 200af54:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
 200af58:	9f c0 40 00 	call  %g1                                      
 200af5c:	d2 07 60 24 	ld  [ %i5 + 0x24 ], %o1                        
                                                                      
       case WATCHDOG_REMOVE_IT:                                       
         break;                                                       
     }                                                                
                                                                      
     _ISR_Disable( level );                                           
 200af60:	7f ff dd 99 	call  20025c4 <sparc_disable_interrupts>       
 200af64:	01 00 00 00 	nop                                            
 200af68:	b0 10 00 08 	mov  %o0, %i0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 200af6c:	fa 07 00 00 	ld  [ %i4 ], %i5                               
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
 200af70:	80 a7 40 1b 	cmp  %i5, %i3                                  
 200af74:	02 80 00 04 	be  200af84 <_Watchdog_Tickle+0x98>            
 200af78:	01 00 00 00 	nop                                            
     }                                                                
                                                                      
     _ISR_Disable( level );                                           
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
 200af7c:	10 bf ff ea 	b  200af24 <_Watchdog_Tickle+0x38>             
 200af80:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
             (the_watchdog->delta_interval == 0) );                   
                                                                      
leave:                                                                
   _ISR_Enable(level);                                                
 200af84:	7f ff dd 94 	call  20025d4 <sparc_enable_interrupts>        
 200af88:	81 e8 00 00 	restore                                        
                                                                      

0200af8c <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) {
 200af8c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
  uintptr_t remaining = rtems_configuration_get_work_space_size();    
 200af90:	05 00 80 69 	sethi  %hi(0x201a400), %g2                     
 200af94:	82 10 a3 78 	or  %g2, 0x378, %g1	! 201a778 <Configuration>  
 200af98:	c6 08 60 32 	ldub  [ %g1 + 0x32 ], %g3                      
 200af9c:	fa 00 a3 78 	ld  [ %g2 + 0x378 ], %i5                       
 200afa0:	80 a0 e0 00 	cmp  %g3, 0                                    
 200afa4:	12 80 00 03 	bne  200afb0 <_Workspace_Handler_initialization+0x24>
 200afa8:	84 10 20 00 	clr  %g2                                       
 200afac:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
  Heap_Area *areas,                                                   
  size_t area_count,                                                  
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
 200afb0:	21 00 80 22 	sethi  %hi(0x2008800), %l0                     
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
 200afb4:	27 00 80 75 	sethi  %hi(0x201d400), %l3                     
  size_t area_count,                                                  
  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();    
 200afb8:	ba 00 80 1d 	add  %g2, %i5, %i5                             
  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) {                                  
 200afbc:	b6 10 20 00 	clr  %i3                                       
  Heap_Area *areas,                                                   
  size_t area_count,                                                  
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
 200afc0:	a0 14 20 b0 	or  %l0, 0xb0, %l0                             
  size_t i;                                                           
                                                                      
  for (i = 0; i < area_count; ++i) {                                  
    Heap_Area *area = &areas [i];                                     
                                                                      
    if ( do_zero ) {                                                  
 200afc4:	e2 08 60 30 	ldub  [ %g1 + 0x30 ], %l1                      
                                                                      
    if ( area->size > overhead ) {                                    
      uintptr_t space_available;                                      
      uintptr_t size;                                                 
                                                                      
      if ( unified ) {                                                
 200afc8:	e4 08 60 31 	ldub  [ %g1 + 0x31 ], %l2                      
  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) {                                  
 200afcc:	10 80 00 2c 	b  200b07c <_Workspace_Handler_initialization+0xf0>
 200afd0:	a6 14 e1 e0 	or  %l3, 0x1e0, %l3                            
    Heap_Area *area = &areas [i];                                     
                                                                      
    if ( do_zero ) {                                                  
 200afd4:	22 80 00 07 	be,a   200aff0 <_Workspace_Handler_initialization+0x64>
 200afd8:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           
      memset( area->begin, 0, area->size );                           
 200afdc:	d0 06 00 00 	ld  [ %i0 ], %o0                               
 200afe0:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
 200afe4:	40 00 14 30 	call  20100a4 <memset>                         
 200afe8:	92 10 20 00 	clr  %o1                                       
    }                                                                 
                                                                      
    if ( area->size > overhead ) {                                    
 200afec:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           
 200aff0:	80 a7 20 16 	cmp  %i4, 0x16                                 
 200aff4:	28 80 00 21 	bleu,a   200b078 <_Workspace_Handler_initialization+0xec>
 200aff8:	b6 06 e0 01 	inc  %i3                                       
      uintptr_t space_available;                                      
      uintptr_t size;                                                 
                                                                      
      if ( unified ) {                                                
 200affc:	80 a4 a0 00 	cmp  %l2, 0                                    
 200b000:	32 80 00 0c 	bne,a   200b030 <_Workspace_Handler_initialization+0xa4>
 200b004:	d2 06 00 00 	ld  [ %i0 ], %o1                               
        size = area->size;                                            
      } else {                                                        
        if ( remaining > 0 ) {                                        
 200b008:	80 a7 60 00 	cmp  %i5, 0                                    
 200b00c:	22 80 00 08 	be,a   200b02c <_Workspace_Handler_initialization+0xa0><== NEVER TAKEN
 200b010:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
          size = remaining < area->size - overhead ?                  
 200b014:	82 07 3f ea 	add  %i4, -22, %g1                             
            remaining + overhead : area->size;                        
 200b018:	80 a7 40 01 	cmp  %i5, %g1                                  
 200b01c:	2a 80 00 04 	bcs,a   200b02c <_Workspace_Handler_initialization+0xa0><== ALWAYS TAKEN
 200b020:	b8 07 60 16 	add  %i5, 0x16, %i4                            
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
 200b024:	10 80 00 03 	b  200b030 <_Workspace_Handler_initialization+0xa4><== NOT EXECUTED
 200b028:	d2 06 00 00 	ld  [ %i0 ], %o1                               <== NOT EXECUTED
 200b02c:	d2 06 00 00 	ld  [ %i0 ], %o1                               
 200b030:	94 10 00 1c 	mov  %i4, %o2                                  
 200b034:	90 10 00 13 	mov  %l3, %o0                                  
 200b038:	9f c4 00 00 	call  %l0                                      
 200b03c:	96 10 20 08 	mov  8, %o3                                    
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
 200b040:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      area->size -= size;                                             
                                                                      
      if ( space_available < remaining ) {                            
 200b044:	80 a2 00 1d 	cmp  %o0, %i5                                  
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
 200b048:	82 00 40 1c 	add  %g1, %i4, %g1                             
 200b04c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
      area->size -= size;                                             
 200b050:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 200b054:	b8 20 40 1c 	sub  %g1, %i4, %i4                             
                                                                      
      if ( space_available < remaining ) {                            
 200b058:	1a 80 00 05 	bcc  200b06c <_Workspace_Handler_initialization+0xe0><== ALWAYS TAKEN
 200b05c:	f8 26 20 04 	st  %i4, [ %i0 + 4 ]                           
        remaining -= space_available;                                 
 200b060:	ba 27 40 08 	sub  %i5, %o0, %i5                             <== NOT EXECUTED
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
 200b064:	10 80 00 04 	b  200b074 <_Workspace_Handler_initialization+0xe8><== NOT EXECUTED
 200b068:	a0 10 00 1a 	mov  %i2, %l0                                  <== NOT EXECUTED
 200b06c:	a0 10 00 1a 	mov  %i2, %l0                                  
      area->size -= size;                                             
                                                                      
      if ( space_available < remaining ) {                            
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
 200b070:	ba 10 20 00 	clr  %i5                                       
  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) {                                  
 200b074:	b6 06 e0 01 	inc  %i3                                       
 200b078:	b0 06 20 08 	add  %i0, 8, %i0                               
 200b07c:	80 a6 c0 19 	cmp  %i3, %i1                                  
 200b080:	12 bf ff d5 	bne  200afd4 <_Workspace_Handler_initialization+0x48>
 200b084:	80 a4 60 00 	cmp  %l1, 0                                    
                                                                      
      init_or_extend = extend;                                        
    }                                                                 
  }                                                                   
                                                                      
  if ( remaining > 0 ) {                                              
 200b088:	80 a7 60 00 	cmp  %i5, 0                                    
 200b08c:	02 80 00 05 	be  200b0a0 <_Workspace_Handler_initialization+0x114>
 200b090:	90 10 20 00 	clr  %o0                                       
    _Internal_error_Occurred(                                         
 200b094:	92 10 20 01 	mov  1, %o1                                    
 200b098:	7f ff f6 99 	call  2008afc <_Internal_error_Occurred>       
 200b09c:	94 10 20 02 	mov  2, %o2                                    
 200b0a0:	81 c7 e0 08 	ret                                            
 200b0a4:	81 e8 00 00 	restore                                        
                                                                      

02013000 <_fat_block_read>: uint32_t start, uint32_t offset, uint32_t count, void *buff ) {
 2013000:	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)                                                 
 2013004:	10 80 00 17 	b  2013060 <_fat_block_read+0x60>              
 2013008:	ba 10 20 00 	clr  %i5                                       
    {                                                                 
        rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
 201300c:	92 10 00 19 	mov  %i1, %o1                                  
 2013010:	94 10 20 01 	mov  1, %o2                                    
 2013014:	7f ff ff cc 	call  2012f44 <fat_buf_access>                 
 2013018:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
 201301c:	80 a2 20 00 	cmp  %o0, 0                                    
 2013020:	32 80 00 15 	bne,a   2013074 <_fat_block_read+0x74>         <== NEVER TAKEN
 2013024:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
            return -1;                                                
                                                                      
        c = MIN(count, (fs_info->vol.bps - ofs));                     
 2013028:	e0 16 00 00 	lduh  [ %i0 ], %l0                             
 201302c:	a0 24 00 1a 	sub  %l0, %i2, %l0                             
 2013030:	80 a4 00 1b 	cmp  %l0, %i3                                  
 2013034:	38 80 00 02 	bgu,a   201303c <_fat_block_read+0x3c>         
 2013038:	a0 10 00 1b 	mov  %i3, %l0                                  
        memcpy((buff + cmpltd), (sec_buf + ofs), c);                  
 201303c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 2013040:	90 07 00 1d 	add  %i4, %i5, %o0                             
 2013044:	92 02 40 1a 	add  %o1, %i2, %o1                             
 2013048:	94 10 00 10 	mov  %l0, %o2                                  
 201304c:	40 00 24 17 	call  201c0a8 <memcpy>                         
 2013050:	b6 26 c0 10 	sub  %i3, %l0, %i3                             
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
 2013054:	ba 04 00 1d 	add  %l0, %i5, %i5                             
        sec_num++;                                                    
 2013058:	b2 06 60 01 	inc  %i1                                       
        ofs = 0;                                                      
 201305c:	b4 10 20 00 	clr  %i2                                       
    uint32_t                sec_num = start;                          
    uint32_t                ofs = offset;                             
    uint8_t                *sec_buf;                                  
    uint32_t                c = 0;                                    
                                                                      
    while (count > 0)                                                 
 2013060:	80 a6 e0 00 	cmp  %i3, 0                                    
 2013064:	12 bf ff ea 	bne  201300c <_fat_block_read+0xc>             
 2013068:	90 10 00 18 	mov  %i0, %o0                                  
        cmpltd += c;                                                  
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
 201306c:	81 c7 e0 08 	ret                                            
 2013070:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
 2013074:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 2013078:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201307c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

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

020045a4 <_stat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
 20045a4:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
 20045a8:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
 20045ac:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 20045b0:	7f ff ff e9 	call  2004554 <stat>                           <== NOT EXECUTED
 20045b4:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

02007750 <aio_cancel>: #include <stdlib.h> #include <rtems/system.h> #include <rtems/seterr.h> int aio_cancel(int fildes, struct aiocb *aiocbp) {
 2007750:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request_chain *r_chain;                                   
  int result;                                                         
                                                                      
  pthread_mutex_lock (&aio_request_queue.mutex);                      
 2007754:	3b 00 80 7e 	sethi  %hi(0x201f800), %i5                     
 2007758:	40 00 04 68 	call  20088f8 <pthread_mutex_lock>             
 200775c:	90 17 61 bc 	or  %i5, 0x1bc, %o0	! 201f9bc <aio_request_queue>
                                                                      
  if (fcntl (fildes, F_GETFD) < 0) {                                  
 2007760:	90 10 00 18 	mov  %i0, %o0                                  
 2007764:	40 00 1a d6 	call  200e2bc <fcntl>                          
 2007768:	92 10 20 01 	mov  1, %o1                                    
 200776c:	80 a2 20 00 	cmp  %o0, 0                                    
 2007770:	16 80 00 08 	bge  2007790 <aio_cancel+0x40>                 
 2007774:	80 a6 60 00 	cmp  %i1, 0                                    
    pthread_mutex_unlock(&aio_request_queue.mutex);                   
 2007778:	40 00 04 81 	call  200897c <pthread_mutex_unlock>           
 200777c:	90 17 61 bc 	or  %i5, 0x1bc, %o0                            
    rtems_set_errno_and_return_minus_one (EBADF);                     
 2007780:	40 00 28 84 	call  2011990 <__errno>                        
 2007784:	01 00 00 00 	nop                                            
 2007788:	10 80 00 54 	b  20078d8 <aio_cancel+0x188>                  
 200778c:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
  }                                                                   
                                                                      
  /* if aiocbp is NULL remove all request for given file descriptor */
  if (aiocbp == NULL) {                                               
 2007790:	32 80 00 35 	bne,a   2007864 <aio_cancel+0x114>             
 2007794:	f8 06 40 00 	ld  [ %i1 ], %i4                               
    AIO_printf ("Cancel all requests\n");                             
                                                                      
    r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
 2007798:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
 200779c:	92 10 00 18 	mov  %i0, %o1                                  
 20077a0:	90 12 22 04 	or  %o0, 0x204, %o0                            
 20077a4:	40 00 01 71 	call  2007d68 <rtems_aio_search_fd>            
 20077a8:	94 10 20 00 	clr  %o2                                       
    if (r_chain == NULL) {                                            
 20077ac:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 20077b0:	12 80 00 20 	bne  2007830 <aio_cancel+0xe0>                 
 20077b4:	b6 07 20 1c 	add  %i4, 0x1c, %i3                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 20077b8:	ba 17 61 bc 	or  %i5, 0x1bc, %i5                            
      AIO_printf ("Request chain not on [WQ]\n");                     
                                                                      
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
 20077bc:	c4 07 60 54 	ld  [ %i5 + 0x54 ], %g2                        
 20077c0:	82 07 60 58 	add  %i5, 0x58, %g1                            
 20077c4:	80 a0 80 01 	cmp  %g2, %g1                                  
 20077c8:	02 80 00 08 	be  20077e8 <aio_cancel+0x98>                  <== NEVER TAKEN
 20077cc:	92 10 00 18 	mov  %i0, %o1                                  
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
 20077d0:	90 07 60 54 	add  %i5, 0x54, %o0                            
 20077d4:	40 00 01 65 	call  2007d68 <rtems_aio_search_fd>            
 20077d8:	94 10 20 00 	clr  %o2                                       
        if (r_chain == NULL) {                                        
 20077dc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 20077e0:	12 80 00 08 	bne  2007800 <aio_cancel+0xb0>                 
 20077e4:	01 00 00 00 	nop                                            
          pthread_mutex_unlock(&aio_request_queue.mutex);             
 20077e8:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
          return AIO_ALLDONE;                                         
 20077ec:	b0 10 20 02 	mov  2, %i0                                    
      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);             
 20077f0:	40 00 04 63 	call  200897c <pthread_mutex_unlock>           
 20077f4:	90 12 21 bc 	or  %o0, 0x1bc, %o0                            
          return AIO_ALLDONE;                                         
 20077f8:	81 c7 e0 08 	ret                                            
 20077fc:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
 2007800:	40 00 0a e1 	call  200a384 <_Chain_Extract>                 
 2007804:	b6 07 20 1c 	add  %i4, 0x1c, %i3                            
        }                                                             
                                                                      
        AIO_printf ("Request chain on [IQ]\n");                       
                                                                      
        rtems_chain_extract (&r_chain->next_fd);                      
        rtems_aio_remove_fd (r_chain);                                
 2007808:	40 00 01 80 	call  2007e08 <rtems_aio_remove_fd>            
 200780c:	90 10 00 1c 	mov  %i4, %o0                                  
        pthread_mutex_destroy (&r_chain->mutex);                      
 2007810:	40 00 03 8d 	call  2008644 <pthread_mutex_destroy>          
 2007814:	90 10 00 1b 	mov  %i3, %o0                                  
        pthread_cond_destroy (&r_chain->mutex);                       
 2007818:	40 00 02 ae 	call  20082d0 <pthread_cond_destroy>           
 200781c:	90 10 00 1b 	mov  %i3, %o0                                  
        free (r_chain);                                               
 2007820:	7f ff f0 c5 	call  2003b34 <free>                           
 2007824:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
        pthread_mutex_unlock (&aio_request_queue.mutex);              
 2007828:	10 80 00 0b 	b  2007854 <aio_cancel+0x104>                  
 200782c:	90 10 00 1d 	mov  %i5, %o0                                  
      return AIO_ALLDONE;                                             
    }                                                                 
                                                                      
    AIO_printf ("Request chain on [WQ]\n");                           
                                                                      
    pthread_mutex_lock (&r_chain->mutex);                             
 2007830:	40 00 04 32 	call  20088f8 <pthread_mutex_lock>             
 2007834:	90 10 00 1b 	mov  %i3, %o0                                  
 2007838:	40 00 0a d3 	call  200a384 <_Chain_Extract>                 
 200783c:	90 10 00 1c 	mov  %i4, %o0                                  
    rtems_chain_extract (&r_chain->next_fd);                          
    rtems_aio_remove_fd (r_chain);                                    
 2007840:	40 00 01 72 	call  2007e08 <rtems_aio_remove_fd>            
 2007844:	90 10 00 1c 	mov  %i4, %o0                                  
    pthread_mutex_unlock (&r_chain->mutex);                           
 2007848:	40 00 04 4d 	call  200897c <pthread_mutex_unlock>           
 200784c:	90 10 00 1b 	mov  %i3, %o0                                  
    pthread_mutex_unlock (&aio_request_queue.mutex);                  
 2007850:	90 17 61 bc 	or  %i5, 0x1bc, %o0                            
 2007854:	40 00 04 4a 	call  200897c <pthread_mutex_unlock>           
 2007858:	b0 10 20 00 	clr  %i0                                       
    return AIO_CANCELED;                                              
 200785c:	81 c7 e0 08 	ret                                            
 2007860:	81 e8 00 00 	restore                                        
  } else {                                                            
    AIO_printf ("Cancel request\n");                                  
                                                                      
    if (aiocbp->aio_fildes != fildes) {                               
 2007864:	80 a7 00 18 	cmp  %i4, %i0                                  
 2007868:	12 80 00 17 	bne  20078c4 <aio_cancel+0x174>                
 200786c:	90 17 61 bc 	or  %i5, 0x1bc, %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);
 2007870:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
 2007874:	92 10 00 1c 	mov  %i4, %o1                                  
 2007878:	90 12 22 04 	or  %o0, 0x204, %o0                            
 200787c:	40 00 01 3b 	call  2007d68 <rtems_aio_search_fd>            
 2007880:	94 10 20 00 	clr  %o2                                       
    if (r_chain == NULL) {                                            
 2007884:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2007888:	32 80 00 1c 	bne,a   20078f8 <aio_cancel+0x1a8>             
 200788c:	b8 06 e0 1c 	add  %i3, 0x1c, %i4                            
 2007890:	ba 17 61 bc 	or  %i5, 0x1bc, %i5                            
      if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {      
 2007894:	c4 07 60 54 	ld  [ %i5 + 0x54 ], %g2                        
 2007898:	82 07 60 58 	add  %i5, 0x58, %g1                            
 200789c:	80 a0 80 01 	cmp  %g2, %g1                                  
 20078a0:	02 bf ff d2 	be  20077e8 <aio_cancel+0x98>                  <== NEVER TAKEN
 20078a4:	92 10 00 1c 	mov  %i4, %o1                                  
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
 20078a8:	90 07 60 54 	add  %i5, 0x54, %o0                            
 20078ac:	40 00 01 2f 	call  2007d68 <rtems_aio_search_fd>            
 20078b0:	94 10 20 00 	clr  %o2                                       
        if (r_chain == NULL) {                                        
 20078b4:	80 a2 20 00 	cmp  %o0, 0                                    
 20078b8:	12 80 00 0b 	bne  20078e4 <aio_cancel+0x194>                
 20078bc:	90 02 20 08 	add  %o0, 8, %o0                               
          pthread_mutex_unlock (&aio_request_queue.mutex);            
 20078c0:	90 10 00 1d 	mov  %i5, %o0                                  
 20078c4:	40 00 04 2e 	call  200897c <pthread_mutex_unlock>           
 20078c8:	01 00 00 00 	nop                                            
          rtems_set_errno_and_return_minus_one (EINVAL);              
 20078cc:	40 00 28 31 	call  2011990 <__errno>                        
 20078d0:	01 00 00 00 	nop                                            
 20078d4:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 20078d8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 20078dc:	81 c7 e0 08 	ret                                            
 20078e0:	91 e8 3f ff 	restore  %g0, -1, %o0                          
        }                                                             
                                                                      
        AIO_printf ("Request on [IQ]\n");                             
                                                                      
        result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);      
 20078e4:	40 00 01 5d 	call  2007e58 <rtems_aio_remove_req>           
 20078e8:	92 10 00 19 	mov  %i1, %o1                                  
 20078ec:	b0 10 00 08 	mov  %o0, %i0                                  
        pthread_mutex_unlock (&aio_request_queue.mutex);              
 20078f0:	10 80 00 0b 	b  200791c <aio_cancel+0x1cc>                  
 20078f4:	90 10 00 1d 	mov  %i5, %o0                                  
        return AIO_ALLDONE;                                           
      }                                                               
    }                                                                 
      AIO_printf ("Request on [WQ]\n");                               
                                                                      
      pthread_mutex_lock (&r_chain->mutex);                           
 20078f8:	40 00 04 00 	call  20088f8 <pthread_mutex_lock>             
 20078fc:	90 10 00 1c 	mov  %i4, %o0                                  
      result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);        
 2007900:	92 10 00 19 	mov  %i1, %o1                                  
 2007904:	40 00 01 55 	call  2007e58 <rtems_aio_remove_req>           
 2007908:	90 06 e0 08 	add  %i3, 8, %o0                               
 200790c:	b0 10 00 08 	mov  %o0, %i0                                  
      pthread_mutex_unlock (&r_chain->mutex);                         
 2007910:	40 00 04 1b 	call  200897c <pthread_mutex_unlock>           
 2007914:	90 10 00 1c 	mov  %i4, %o0                                  
      pthread_mutex_unlock (&aio_request_queue.mutex);                
 2007918:	90 17 61 bc 	or  %i5, 0x1bc, %o0                            
 200791c:	40 00 04 18 	call  200897c <pthread_mutex_unlock>           
 2007920:	01 00 00 00 	nop                                            
      return result;                                                  
  }                                                                   
  return AIO_ALLDONE;                                                 
}                                                                     
 2007924:	81 c7 e0 08 	ret                                            
 2007928:	81 e8 00 00 	restore                                        
                                                                      

02007934 <aio_fsync>: int aio_fsync( int op, struct aiocb *aiocbp ) {
 2007934:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  if (op != O_SYNC)                                                   
 2007938:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
 200793c:	80 a6 00 01 	cmp  %i0, %g1                                  
 2007940:	12 80 00 10 	bne  2007980 <aio_fsync+0x4c>                  
 2007944:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
 2007948:	d0 06 40 00 	ld  [ %i1 ], %o0                               
 200794c:	40 00 1a 5c 	call  200e2bc <fcntl>                          
 2007950:	92 10 20 03 	mov  3, %o1                                    
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
 2007954:	90 0a 20 03 	and  %o0, 3, %o0                               
 2007958:	90 02 3f ff 	add  %o0, -1, %o0                              
 200795c:	80 a2 20 01 	cmp  %o0, 1                                    
 2007960:	18 80 00 08 	bgu  2007980 <aio_fsync+0x4c>                  
 2007964:	ba 10 20 09 	mov  9, %i5                                    
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
 2007968:	7f ff f1 93 	call  2003fb4 <malloc>                         
 200796c:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
 2007970:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2007974:	32 80 00 09 	bne,a   2007998 <aio_fsync+0x64>               <== ALWAYS TAKEN
 2007978:	f2 26 20 14 	st  %i1, [ %i0 + 0x14 ]                        
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
 200797c:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
 2007980:	82 10 3f ff 	mov  -1, %g1                                   
 2007984:	fa 26 60 34 	st  %i5, [ %i1 + 0x34 ]                        
 2007988:	40 00 28 02 	call  2011990 <__errno>                        
 200798c:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
 2007990:	10 80 00 06 	b  20079a8 <aio_fsync+0x74>                    
 2007994:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_SYNC;                             
 2007998:	82 10 20 03 	mov  3, %g1                                    
 200799c:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
 20079a0:	40 00 01 4e 	call  2007ed8 <rtems_aio_enqueue>              
 20079a4:	81 e8 00 00 	restore                                        
                                                                      
}                                                                     
 20079a8:	81 c7 e0 08 	ret                                            
 20079ac:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

020080f0 <aio_read>: * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) {
 20080f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
 20080f4:	d0 06 00 00 	ld  [ %i0 ], %o0                               
 20080f8:	92 10 20 03 	mov  3, %o1                                    
 20080fc:	40 00 18 70 	call  200e2bc <fcntl>                          
 2008100:	ba 10 00 18 	mov  %i0, %i5                                  
  if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
 2008104:	80 8a 20 01 	btst  1, %o0                                   
 2008108:	12 80 00 11 	bne  200814c <aio_read+0x5c>                   
 200810c:	b8 10 20 09 	mov  9, %i4                                    
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
 2008110:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 2008114:	80 a0 60 00 	cmp  %g1, 0                                    
 2008118:	22 80 00 04 	be,a   2008128 <aio_read+0x38>                 
 200811c:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
 2008120:	10 80 00 0b 	b  200814c <aio_read+0x5c>                     
 2008124:	b8 10 20 16 	mov  0x16, %i4                                 
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
 2008128:	80 a0 60 00 	cmp  %g1, 0                                    
 200812c:	06 80 00 08 	bl  200814c <aio_read+0x5c>                    
 2008130:	b8 10 20 16 	mov  0x16, %i4                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
 2008134:	7f ff ef a0 	call  2003fb4 <malloc>                         
 2008138:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
 200813c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2008140:	32 80 00 09 	bne,a   2008164 <aio_read+0x74>                <== ALWAYS TAKEN
 2008144:	fa 26 20 14 	st  %i5, [ %i0 + 0x14 ]                        
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
 2008148:	b8 10 20 0b 	mov  0xb, %i4                                  <== NOT EXECUTED
 200814c:	82 10 3f ff 	mov  -1, %g1                                   
 2008150:	f8 27 60 34 	st  %i4, [ %i5 + 0x34 ]                        
 2008154:	40 00 26 0f 	call  2011990 <__errno>                        
 2008158:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
 200815c:	10 80 00 06 	b  2008174 <aio_read+0x84>                     
 2008160:	f8 22 00 00 	st  %i4, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_READ;                             
 2008164:	82 10 20 01 	mov  1, %g1                                    
 2008168:	c2 27 60 30 	st  %g1, [ %i5 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
 200816c:	7f ff ff 5b 	call  2007ed8 <rtems_aio_enqueue>              
 2008170:	81 e8 00 00 	restore                                        
}                                                                     
 2008174:	81 c7 e0 08 	ret                                            
 2008178:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

02008184 <aio_write>: * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) {
 2008184:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
 2008188:	d0 06 00 00 	ld  [ %i0 ], %o0                               
 200818c:	40 00 18 4c 	call  200e2bc <fcntl>                          
 2008190:	92 10 20 03 	mov  3, %o1                                    
 *         0 - otherwise                                              
 */                                                                   
                                                                      
int                                                                   
aio_write (struct aiocb *aiocbp)                                      
{                                                                     
 2008194:	ba 10 00 18 	mov  %i0, %i5                                  
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
 2008198:	90 0a 20 03 	and  %o0, 3, %o0                               
 200819c:	90 02 3f ff 	add  %o0, -1, %o0                              
 20081a0:	80 a2 20 01 	cmp  %o0, 1                                    
 20081a4:	18 80 00 11 	bgu  20081e8 <aio_write+0x64>                  
 20081a8:	b8 10 20 09 	mov  9, %i4                                    
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
 20081ac:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 20081b0:	80 a0 60 00 	cmp  %g1, 0                                    
 20081b4:	22 80 00 04 	be,a   20081c4 <aio_write+0x40>                
 20081b8:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
 20081bc:	10 80 00 0b 	b  20081e8 <aio_write+0x64>                    
 20081c0:	b8 10 20 16 	mov  0x16, %i4                                 
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
 20081c4:	80 a0 60 00 	cmp  %g1, 0                                    
 20081c8:	06 80 00 08 	bl  20081e8 <aio_write+0x64>                   
 20081cc:	b8 10 20 16 	mov  0x16, %i4                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
 20081d0:	7f ff ef 79 	call  2003fb4 <malloc>                         
 20081d4:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
 20081d8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20081dc:	32 80 00 09 	bne,a   2008200 <aio_write+0x7c>               <== ALWAYS TAKEN
 20081e0:	fa 26 20 14 	st  %i5, [ %i0 + 0x14 ]                        
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
 20081e4:	b8 10 20 0b 	mov  0xb, %i4                                  <== NOT EXECUTED
 20081e8:	82 10 3f ff 	mov  -1, %g1                                   
 20081ec:	f8 27 60 34 	st  %i4, [ %i5 + 0x34 ]                        
 20081f0:	40 00 25 e8 	call  2011990 <__errno>                        
 20081f4:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
 20081f8:	10 80 00 06 	b  2008210 <aio_write+0x8c>                    
 20081fc:	f8 22 00 00 	st  %i4, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_WRITE;                            
 2008200:	82 10 20 02 	mov  2, %g1                                    
 2008204:	c2 27 60 30 	st  %g1, [ %i5 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
 2008208:	7f ff ff 34 	call  2007ed8 <rtems_aio_enqueue>              
 200820c:	81 e8 00 00 	restore                                        
}                                                                     
 2008210:	81 c7 e0 08 	ret                                            
 2008214:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

02003990 <chroot>: #include <unistd.h> #include <rtems/libio_.h> int chroot( const char *path ) {
 2003990:	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(             
 2003994:	94 10 20 19 	mov  0x19, %o2                                 
 2003998:	92 10 00 18 	mov  %i0, %o1                                  
 200399c:	90 07 bf c8 	add  %fp, -56, %o0                             
 20039a0:	17 00 80 48 	sethi  %hi(0x2012000), %o3                     
 20039a4:	96 12 e1 e4 	or  %o3, 0x1e4, %o3	! 20121e4 <rtems_global_user_env+0x4>
 20039a8:	40 00 04 c3 	call  2004cb4 <rtems_filesystem_eval_path_start_with_root_and_current>
 20039ac:	98 02 ff fc 	add  %o3, -4, %o4                              
 20039b0:	90 07 bf b0 	add  %fp, -80, %o0                             
 20039b4:	40 00 05 da 	call  200511c <rtems_filesystem_location_copy_and_detach>
 20039b8:	92 07 bf e0 	add  %fp, -32, %o1                             
    &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 );
 20039bc:	40 00 06 50 	call  20052fc <rtems_filesystem_location_transform_to_global>
 20039c0:	90 07 bf b0 	add  %fp, -80, %o0                             
  if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
 20039c4:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
 20039c8:	39 00 80 46 	sethi  %hi(0x2011800), %i4                     
 20039cc:	b8 17 22 b4 	or  %i4, 0x2b4, %i4	! 2011ab4 <rtems_filesystem_null_handlers>
 20039d0:	80 a0 40 1c 	cmp  %g1, %i4                                  
 20039d4:	02 80 00 29 	be  2003a78 <chroot+0xe8>                      
 20039d8:	d0 27 bf ac 	st  %o0, [ %fp + -84 ]                         
    rtems_filesystem_global_location_t *new_root_loc =                
 20039dc:	40 00 06 16 	call  2005234 <rtems_filesystem_global_location_obtain>
 20039e0:	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)(           
 20039e4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
 20039e8:	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 =                              
 20039ec:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
 20039f0:	9f c0 40 00 	call  %g1                                      
 20039f4:	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 ) {                       
 20039f8:	80 a2 20 00 	cmp  %o0, 0                                    
 20039fc:	32 80 00 17 	bne,a   2003a58 <chroot+0xc8>                  
 2003a00:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
      sc = rtems_libio_set_private_env();                             
 2003a04:	40 00 03 1d 	call  2004678 <rtems_libio_set_private_env>    
 2003a08:	01 00 00 00 	nop                                            
      if (sc == RTEMS_SUCCESSFUL) {                                   
 2003a0c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003a10:	12 80 00 0c 	bne  2003a40 <chroot+0xb0>                     
 2003a14:	80 a2 20 0d 	cmp  %o0, 0xd                                  
        rtems_filesystem_global_location_assign(                      
 2003a18:	39 00 80 48 	sethi  %hi(0x2012000), %i4                     
 2003a1c:	d0 07 21 dc 	ld  [ %i4 + 0x1dc ], %o0	! 20121dc <rtems_current_user_env>
 2003a20:	92 10 00 1d 	mov  %i5, %o1                                  
 2003a24:	40 00 05 fb 	call  2005210 <rtems_filesystem_global_location_assign>
 2003a28:	90 02 20 04 	add  %o0, 4, %o0                               
          &rtems_filesystem_root,                                     
          new_root_loc                                                
        );                                                            
        rtems_filesystem_global_location_assign(                      
 2003a2c:	d0 07 21 dc 	ld  [ %i4 + 0x1dc ], %o0                       
 2003a30:	d2 07 bf ac 	ld  [ %fp + -84 ], %o1                         
 2003a34:	40 00 05 f7 	call  2005210 <rtems_filesystem_global_location_assign>
 2003a38:	b0 10 20 00 	clr  %i0                                       
 2003a3c:	30 80 00 10 	b,a   2003a7c <chroot+0xec>                    
          &rtems_filesystem_current,                                  
          new_current_loc                                             
        );                                                            
      } else {                                                        
        if (sc != RTEMS_UNSATISFIED) {                                
 2003a40:	02 80 00 18 	be  2003aa0 <chroot+0x110>                     <== NEVER TAKEN
 2003a44:	01 00 00 00 	nop                                            
          errno = ENOMEM;                                             
 2003a48:	40 00 1f f5 	call  200ba1c <__errno>                        
 2003a4c:	01 00 00 00 	nop                                            
 2003a50:	10 80 00 08 	b  2003a70 <chroot+0xe0>                       
 2003a54:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
static inline void rtems_filesystem_location_error(                   
  const rtems_filesystem_location_info_t *loc,                        
  int eno                                                             
)                                                                     
{                                                                     
  if ( !rtems_filesystem_location_is_null( loc ) ) {                  
 2003a58:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2003a5c:	02 80 00 11 	be  2003aa0 <chroot+0x110>                     <== NEVER TAKEN
 2003a60:	01 00 00 00 	nop                                            
    errno = eno;                                                      
 2003a64:	40 00 1f ee 	call  200ba1c <__errno>                        
 2003a68:	01 00 00 00 	nop                                            
 2003a6c:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          
 2003a70:	10 80 00 0c 	b  2003aa0 <chroot+0x110>                      
 2003a74:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
    if ( rv != 0 ) {                                                  
      rtems_filesystem_global_location_release( new_root_loc );       
    }                                                                 
  } else {                                                            
    rv = -1;                                                          
 2003a78:	b0 10 3f ff 	mov  -1, %i0                                   
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
 2003a7c:	40 00 04 d4 	call  2004dcc <rtems_filesystem_eval_path_cleanup>
 2003a80:	90 07 bf c8 	add  %fp, -56, %o0                             
                                                                      
  if ( rv != 0 ) {                                                    
 2003a84:	80 a6 20 00 	cmp  %i0, 0                                    
 2003a88:	02 80 00 0a 	be  2003ab0 <chroot+0x120>                     
 2003a8c:	01 00 00 00 	nop                                            
    rtems_filesystem_global_location_release( new_current_loc );      
 2003a90:	40 00 05 c8 	call  20051b0 <rtems_filesystem_global_location_release>
 2003a94:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
 2003a98:	81 c7 e0 08 	ret                                            
 2003a9c:	81 e8 00 00 	restore                                        
      rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
      rv = -1;                                                        
    }                                                                 
                                                                      
    if ( rv != 0 ) {                                                  
      rtems_filesystem_global_location_release( new_root_loc );       
 2003aa0:	40 00 05 c4 	call  20051b0 <rtems_filesystem_global_location_release>
 2003aa4:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
  } else {                                                            
    rv = -1;                                                          
 2003aa8:	10 bf ff f5 	b  2003a7c <chroot+0xec>                       
 2003aac:	b0 10 3f ff 	mov  -1, %i0                                   
  if ( rv != 0 ) {                                                    
    rtems_filesystem_global_location_release( new_current_loc );      
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2003ab0:	81 c7 e0 08 	ret                                            
 2003ab4:	81 e8 00 00 	restore                                        
                                                                      

0200736c <clock_gettime>: int clock_gettime( clockid_t clock_id, struct timespec *tp ) {
 200736c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !tp )                                                          
 2007370:	80 a6 60 00 	cmp  %i1, 0                                    
 2007374:	02 80 00 26 	be  200740c <clock_gettime+0xa0>               
 2007378:	80 a6 20 01 	cmp  %i0, 1                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
 200737c:	12 80 00 16 	bne  20073d4 <clock_gettime+0x68>              
 2007380:	80 a6 20 04 	cmp  %i0, 4                                    
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
 2007384:	90 07 bf f8 	add  %fp, -8, %o0                              
 2007388:	13 00 80 82 	sethi  %hi(0x2020800), %o1                     
 200738c:	40 00 08 2f 	call  2009448 <_TOD_Get_with_nanoseconds>      
 2007390:	92 12 62 88 	or  %o1, 0x288, %o1	! 2020a88 <_TOD>           
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
                                                                      
  return 0;                                                           
}                                                                     
 2007394:	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);           
 2007398:	94 10 20 00 	clr  %o2                                       
 200739c:	90 10 00 1c 	mov  %i4, %o0                                  
 20073a0:	92 10 00 1d 	mov  %i5, %o1                                  
 20073a4:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 20073a8:	40 00 53 1c 	call  201c018 <__divdi3>                       
 20073ac:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 20073b0:	90 10 00 1c 	mov  %i4, %o0                                  
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
 20073b4:	d2 26 40 00 	st  %o1, [ %i1 ]                               
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 20073b8:	94 10 20 00 	clr  %o2                                       
 20073bc:	92 10 00 1d 	mov  %i5, %o1                                  
 20073c0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 20073c4:	40 00 54 00 	call  201c3c4 <__moddi3>                       
 20073c8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
 20073cc:	10 80 00 06 	b  20073e4 <clock_gettime+0x78>                
 20073d0:	d2 26 60 04 	st  %o1, [ %i1 + 4 ]                           
  if ( clock_id == CLOCK_REALTIME ) {                                 
    _TOD_Get(tp);                                                     
    return 0;                                                         
  }                                                                   
#ifdef CLOCK_MONOTONIC                                                
  if ( clock_id == CLOCK_MONOTONIC ) {                                
 20073d4:	12 80 00 06 	bne  20073ec <clock_gettime+0x80>              <== ALWAYS TAKEN
 20073d8:	80 a6 20 02 	cmp  %i0, 2                                    
    _TOD_Get_uptime_as_timespec( tp );                                
 20073dc:	40 00 08 2c 	call  200948c <_TOD_Get_uptime_as_timespec>    
 20073e0:	90 10 00 19 	mov  %i1, %o0                                  
    return 0;                                                         
 20073e4:	81 c7 e0 08 	ret                                            
 20073e8:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_CPUTIME                                                 
  if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {                       
 20073ec:	02 bf ff fc 	be  20073dc <clock_gettime+0x70>               
 20073f0:	80 a6 20 03 	cmp  %i0, 3                                    
    return 0;                                                         
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_THREAD_CPUTIME                                          
  if ( clock_id == CLOCK_THREAD_CPUTIME_ID )                          
 20073f4:	12 80 00 06 	bne  200740c <clock_gettime+0xa0>              
 20073f8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
 20073fc:	40 00 24 d8 	call  201075c <__errno>                        
 2007400:	01 00 00 00 	nop                                            
 2007404:	10 80 00 05 	b  2007418 <clock_gettime+0xac>                
 2007408:	82 10 20 58 	mov  0x58, %g1	! 58 <PROM_START+0x58>          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
 200740c:	40 00 24 d4 	call  201075c <__errno>                        
 2007410:	01 00 00 00 	nop                                            
 2007414:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2007418:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
  return 0;                                                           
}                                                                     
 200741c:	81 c7 e0 08 	ret                                            
 2007420:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

02025890 <clock_settime>: int clock_settime( clockid_t clock_id, const struct timespec *tp ) {
 2025890:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !tp )                                                          
 2025894:	82 96 60 00 	orcc  %i1, 0, %g1                              
 2025898:	02 80 00 4b 	be  20259c4 <clock_settime+0x134>              <== NEVER TAKEN
 202589c:	80 a6 20 01 	cmp  %i0, 1                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
 20258a0:	12 80 00 41 	bne  20259a4 <clock_settime+0x114>             
 20258a4:	80 a6 20 02 	cmp  %i0, 2                                    
    if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )                 
 20258a8:	c6 00 40 00 	ld  [ %g1 ], %g3                               
 20258ac:	05 08 76 b9 	sethi  %hi(0x21dae400), %g2                    
 20258b0:	84 10 a0 ff 	or  %g2, 0xff, %g2	! 21dae4ff <RAM_END+0x1f9ae4ff>
 20258b4:	80 a0 c0 02 	cmp  %g3, %g2                                  
 20258b8:	08 80 00 43 	bleu  20259c4 <clock_settime+0x134>            
 20258bc:	05 00 81 88 	sethi  %hi(0x2062000), %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;                  
 20258c0:	c6 00 a0 40 	ld  [ %g2 + 0x40 ], %g3	! 2062040 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 20258c4:	86 00 e0 01 	inc  %g3                                       
    _Thread_Dispatch_disable_level = level;                           
 20258c8:	c6 20 a0 40 	st  %g3, [ %g2 + 0x40 ]                        
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
 20258cc:	c6 00 40 00 	ld  [ %g1 ], %g3                               
    &tod_as_timestamp,                                                
    tod_as_timespec->tv_sec,                                          
    tod_as_timespec->tv_nsec                                          
  );                                                                  
  _TOD_Set_with_timestamp( &tod_as_timestamp );                       
 20258d0:	90 07 bf f8 	add  %fp, -8, %o0                              
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
 20258d4:	85 38 e0 1f 	sra  %g3, 0x1f, %g2                            
  Timestamp64_Control *_time,                                         
  Timestamp64_Control  _seconds,                                      
  Timestamp64_Control  _nanoseconds                                   
)                                                                     
{                                                                     
  *_time = _seconds * 1000000000L + _nanoseconds;                     
 20258d8:	89 28 a0 03 	sll  %g2, 3, %g4                               
 20258dc:	bb 28 e0 03 	sll  %g3, 3, %i5                               
 20258e0:	b7 30 e0 1d 	srl  %g3, 0x1d, %i3                            
 20258e4:	b8 16 c0 04 	or  %i3, %g4, %i4                              
 20258e8:	89 37 60 1b 	srl  %i5, 0x1b, %g4                            
 20258ec:	b5 2f 20 05 	sll  %i4, 5, %i2                               
 20258f0:	b7 2f 60 05 	sll  %i5, 5, %i3                               
 20258f4:	b4 11 00 1a 	or  %g4, %i2, %i2                              
 20258f8:	ba a6 c0 1d 	subcc  %i3, %i5, %i5                           
 20258fc:	89 37 60 1a 	srl  %i5, 0x1a, %g4                            
 2025900:	b8 66 80 1c 	subx  %i2, %i4, %i4                            
 2025904:	b7 2f 60 06 	sll  %i5, 6, %i3                               
 2025908:	b5 2f 20 06 	sll  %i4, 6, %i2                               
 202590c:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
 2025910:	b4 11 00 1a 	or  %g4, %i2, %i2                              
 2025914:	b4 66 80 1c 	subx  %i2, %i4, %i2                            
 2025918:	b2 86 c0 03 	addcc  %i3, %g3, %i1                           
 202591c:	b0 46 80 02 	addx  %i2, %g2, %i0                            
 2025920:	89 36 60 1e 	srl  %i1, 0x1e, %g4                            
 2025924:	85 2e 20 02 	sll  %i0, 2, %g2                               
 2025928:	84 11 00 02 	or  %g4, %g2, %g2                              
 202592c:	87 2e 60 02 	sll  %i1, 2, %g3                               
 2025930:	ba 86 40 03 	addcc  %i1, %g3, %i5                           
 2025934:	b8 46 00 02 	addx  %i0, %g2, %i4                            
 2025938:	89 37 60 1e 	srl  %i5, 0x1e, %g4                            
 202593c:	85 2f 20 02 	sll  %i4, 2, %g2                               
 2025940:	84 11 00 02 	or  %g4, %g2, %g2                              
 2025944:	87 2f 60 02 	sll  %i5, 2, %g3                               
 2025948:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
 202594c:	b4 47 00 02 	addx  %i4, %g2, %i2                            
 2025950:	bb 2e e0 02 	sll  %i3, 2, %i5                               
 2025954:	85 36 e0 1e 	srl  %i3, 0x1e, %g2                            
 2025958:	86 86 c0 1d 	addcc  %i3, %i5, %g3                           
 202595c:	b9 2e a0 02 	sll  %i2, 2, %i4                               
 2025960:	b8 10 80 1c 	or  %g2, %i4, %i4                              
 2025964:	84 46 80 1c 	addx  %i2, %i4, %g2                            
 2025968:	bb 28 a0 09 	sll  %g2, 9, %i5                               
 202596c:	b9 30 e0 17 	srl  %g3, 0x17, %i4                            
 2025970:	84 17 00 1d 	or  %i4, %i5, %g2                              
 2025974:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
 2025978:	89 28 e0 09 	sll  %g3, 9, %g4                               
 202597c:	b6 81 00 1d 	addcc  %g4, %i5, %i3                           
 2025980:	b9 3f 60 1f 	sra  %i5, 0x1f, %i4                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  return 0;                                                           
 2025984:	b0 10 20 00 	clr  %i0                                       
 2025988:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
    &tod_as_timestamp,                                                
    tod_as_timespec->tv_sec,                                          
    tod_as_timespec->tv_nsec                                          
  );                                                                  
  _TOD_Set_with_timestamp( &tod_as_timestamp );                       
 202598c:	40 00 04 3b 	call  2026a78 <_TOD_Set_with_timestamp>        
 2025990:	f4 3f bf f8 	std  %i2, [ %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();                                        
 2025994:	7f ff 90 d0 	call  2009cd4 <_Thread_Enable_dispatch>        
 2025998:	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;                                                           
 202599c:	81 c7 e0 08 	ret                                            
 20259a0:	81 e8 00 00 	restore                                        
    _Thread_Disable_dispatch();                                       
      _TOD_Set( tp );                                                 
    _Thread_Enable_dispatch();                                        
  }                                                                   
#ifdef _POSIX_CPUTIME                                                 
  else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )                    
 20259a4:	02 80 00 04 	be  20259b4 <clock_settime+0x124>              
 20259a8:	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 )                     
 20259ac:	12 80 00 06 	bne  20259c4 <clock_settime+0x134>             
 20259b0:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
 20259b4:	40 00 44 28 	call  2036a54 <__errno>                        
 20259b8:	01 00 00 00 	nop                                            
 20259bc:	10 80 00 05 	b  20259d0 <clock_settime+0x140>               
 20259c0:	82 10 20 58 	mov  0x58, %g1	! 58 <PROM_START+0x58>          
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
 20259c4:	40 00 44 24 	call  2036a54 <__errno>                        
 20259c8:	01 00 00 00 	nop                                            
 20259cc:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 20259d0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
  return 0;                                                           
}                                                                     
 20259d4:	81 c7 e0 08 	ret                                            
 20259d8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

02003624 <create_disk>: dev_t dev, const char *name, rtems_disk_device **dd_ptr, char **alloc_name_ptr ) {
 2003624:	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) {                                        
 2003628:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200362c:	e0 00 61 30 	ld  [ %g1 + 0x130 ], %l0	! 2021530 <disktab_size>
 2003630:	80 a6 00 10 	cmp  %i0, %l0                                  
 2003634:	0a 80 00 16 	bcs  200368c <create_disk+0x68>                
 2003638:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    rtems_disk_device_table *table = disktab;                         
    rtems_device_major_number old_size = disktab_size;                
    rtems_device_major_number new_size = 2 * old_size;                
 200363c:	bb 2c 20 01 	sll  %l0, 1, %i5                               
                                                                      
    if (major >= new_size) {                                          
 2003640:	80 a6 00 1d 	cmp  %i0, %i5                                  
 2003644:	0a 80 00 03 	bcs  2003650 <create_disk+0x2c>                <== NEVER TAKEN
 2003648:	d0 00 61 34 	ld  [ %g1 + 0x134 ], %o0                       
      new_size = major + 1;                                           
 200364c:	ba 06 20 01 	add  %i0, 1, %i5                               
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
 2003650:	40 00 08 7a 	call  2005838 <realloc>                        
 2003654:	93 2f 60 03 	sll  %i5, 3, %o1                               
    if (table == NULL) {                                              
 2003658:	a2 92 20 00 	orcc  %o0, 0, %l1                              
 200365c:	02 80 00 58 	be  20037bc <create_disk+0x198>                <== ALWAYS TAKEN
 2003660:	94 27 40 10 	sub  %i5, %l0, %o2                             
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
 2003664:	91 2c 20 03 	sll  %l0, 3, %o0                               <== NOT EXECUTED
 2003668:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 200366c:	90 04 40 08 	add  %l1, %o0, %o0                             <== NOT EXECUTED
 2003670:	40 00 43 6e 	call  2014428 <memset>                         <== NOT EXECUTED
 2003674:	95 2a a0 03 	sll  %o2, 3, %o2                               <== NOT EXECUTED
    disktab = table;                                                  
 2003678:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
 200367c:	e2 20 61 34 	st  %l1, [ %g1 + 0x134 ]	! 2021534 <disktab>   <== NOT EXECUTED
    disktab_size = new_size;                                          
 2003680:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
 2003684:	fa 20 61 30 	st  %i5, [ %g1 + 0x130 ]	! 2021530 <disktab_size><== NOT EXECUTED
  }                                                                   
                                                                      
  if (disktab [major].minor == NULL || minor >= disktab[major].size) {
 2003688:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
 200368c:	e4 00 61 34 	ld  [ %g1 + 0x134 ], %l2	! 2021534 <disktab>   
 2003690:	a3 2e 20 03 	sll  %i0, 3, %l1                               
 2003694:	d0 04 80 11 	ld  [ %l2 + %l1 ], %o0                         
 2003698:	a8 04 80 11 	add  %l2, %l1, %l4                             
 200369c:	80 a2 20 00 	cmp  %o0, 0                                    
 20036a0:	02 80 00 05 	be  20036b4 <create_disk+0x90>                 
 20036a4:	e0 05 20 04 	ld  [ %l4 + 4 ], %l0                           
 20036a8:	80 a6 40 10 	cmp  %i1, %l0                                  
 20036ac:	2a 80 00 16 	bcs,a   2003704 <create_disk+0xe0>             
 20036b0:	e2 04 80 11 	ld  [ %l2 + %l1 ], %l1                         
    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) {                                              
 20036b4:	80 a4 20 00 	cmp  %l0, 0                                    
 20036b8:	02 80 00 03 	be  20036c4 <create_disk+0xa0>                 
 20036bc:	ba 10 20 08 	mov  8, %i5                                    
      new_size = DISKTAB_INITIAL_SIZE;                                
    } else {                                                          
      new_size = 2 * old_size;                                        
 20036c0:	bb 2c 20 01 	sll  %l0, 1, %i5                               
    }                                                                 
    if (minor >= new_size) {                                          
 20036c4:	80 a6 40 1d 	cmp  %i1, %i5                                  
 20036c8:	3a 80 00 02 	bcc,a   20036d0 <create_disk+0xac>             
 20036cc:	ba 06 60 01 	add  %i1, 1, %i5                               
      new_size = minor + 1;                                           
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
 20036d0:	40 00 08 5a 	call  2005838 <realloc>                        
 20036d4:	93 2f 60 02 	sll  %i5, 2, %o1                               
    if (table == NULL) {                                              
 20036d8:	a6 92 20 00 	orcc  %o0, 0, %l3                              
 20036dc:	02 80 00 38 	be  20037bc <create_disk+0x198>                
 20036e0:	94 27 40 10 	sub  %i5, %l0, %o2                             
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
 20036e4:	91 2c 20 02 	sll  %l0, 2, %o0                               
 20036e8:	92 10 20 00 	clr  %o1                                       
 20036ec:	90 04 c0 08 	add  %l3, %o0, %o0                             
 20036f0:	40 00 43 4e 	call  2014428 <memset>                         
 20036f4:	95 2a a0 02 	sll  %o2, 2, %o2                               
    disktab [major].minor = table;                                    
 20036f8:	e6 24 80 11 	st  %l3, [ %l2 + %l1 ]                         
    disktab [major].size = new_size;                                  
 20036fc:	fa 25 20 04 	st  %i5, [ %l4 + 4 ]                           
  }                                                                   
                                                                      
  return disktab [major].minor + minor;                               
 2003700:	e2 04 80 11 	ld  [ %l2 + %l1 ], %l1                         
 2003704:	a1 2e 60 02 	sll  %i1, 2, %l0                               
 2003708:	82 04 40 10 	add  %l1, %l0, %g1                             
{                                                                     
  rtems_disk_device **dd_entry = create_disk_table_entry(dev);        
  rtems_disk_device *dd = NULL;                                       
  char *alloc_name = NULL;                                            
                                                                      
  if (dd_entry == NULL) {                                             
 200370c:	80 a0 60 00 	cmp  %g1, 0                                    
 2003710:	32 80 00 04 	bne,a   2003720 <create_disk+0xfc>             <== ALWAYS TAKEN
 2003714:	c4 04 40 10 	ld  [ %l1 + %l0 ], %g2                         
    return RTEMS_NO_MEMORY;                                           
 2003718:	10 80 00 2a 	b  20037c0 <create_disk+0x19c>                 <== NOT EXECUTED
 200371c:	82 10 20 1a 	mov  0x1a, %g1                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  if (*dd_entry != NULL) {                                            
 2003720:	80 a0 a0 00 	cmp  %g2, 0                                    
 2003724:	12 80 00 27 	bne  20037c0 <create_disk+0x19c>               
 2003728:	82 10 20 0c 	mov  0xc, %g1                                  
    return RTEMS_RESOURCE_IN_USE;                                     
  }                                                                   
                                                                      
  dd = malloc(sizeof(*dd));                                           
 200372c:	40 00 05 7d 	call  2004d20 <malloc>                         
 2003730:	90 10 20 78 	mov  0x78, %o0                                 
  if (dd == NULL) {                                                   
 2003734:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2003738:	02 80 00 21 	be  20037bc <create_disk+0x198>                <== NEVER TAKEN
 200373c:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
 2003740:	02 80 00 11 	be  2003784 <create_disk+0x160>                
 2003744:	a4 10 20 00 	clr  %l2                                       
    alloc_name = strdup(name);                                        
 2003748:	40 00 44 91 	call  201498c <strdup>                         
 200374c:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    if (alloc_name == NULL) {                                         
 2003750:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 2003754:	12 80 00 11 	bne  2003798 <create_disk+0x174>               <== ALWAYS TAKEN
 2003758:	b4 10 00 08 	mov  %o0, %i2                                  
      free(dd);                                                       
 200375c:	40 00 04 30 	call  200481c <free>                           <== NOT EXECUTED
 2003760:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  rtems_disk_device **dd_entry = create_disk_table_entry(dev);        
  rtems_disk_device *dd = NULL;                                       
  char *alloc_name = NULL;                                            
                                                                      
  if (dd_entry == NULL) {                                             
    return RTEMS_NO_MEMORY;                                           
 2003764:	10 80 00 17 	b  20037c0 <create_disk+0x19c>                 <== NOT EXECUTED
 2003768:	82 10 20 1a 	mov  0x1a, %g1                                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
      free(alloc_name);                                               
 200376c:	40 00 04 2c 	call  200481c <free>                           <== NOT EXECUTED
 2003770:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
      free(dd);                                                       
 2003774:	40 00 04 2a 	call  200481c <free>                           <== NOT EXECUTED
 2003778:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      return RTEMS_UNSATISFIED;                                       
 200377c:	10 80 00 11 	b  20037c0 <create_disk+0x19c>                 <== NOT EXECUTED
 2003780:	82 10 20 0d 	mov  0xd, %g1                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  *dd_entry = dd;                                                     
 2003784:	fa 24 40 10 	st  %i5, [ %l1 + %l0 ]                         
  *dd_ptr = dd;                                                       
 2003788:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
  *alloc_name_ptr = alloc_name;                                       
 200378c:	e4 27 00 00 	st  %l2, [ %i4 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 2003790:	10 80 00 0c 	b  20037c0 <create_disk+0x19c>                 
 2003794:	82 10 20 00 	clr  %g1                                       
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
 2003798:	13 00 00 18 	sethi  %hi(0x6000), %o1                        
 200379c:	94 10 00 18 	mov  %i0, %o2                                  
 20037a0:	92 12 61 ff 	or  %o1, 0x1ff, %o1                            
 20037a4:	40 00 05 cf 	call  2004ee0 <mknod>                          
 20037a8:	96 10 00 19 	mov  %i1, %o3                                  
 20037ac:	80 a2 20 00 	cmp  %o0, 0                                    
 20037b0:	36 bf ff f6 	bge,a   2003788 <create_disk+0x164>            <== ALWAYS TAKEN
 20037b4:	fa 24 40 10 	st  %i5, [ %l1 + %l0 ]                         
 20037b8:	30 bf ff ed 	b,a   200376c <create_disk+0x148>              <== NOT EXECUTED
  rtems_disk_device **dd_entry = create_disk_table_entry(dev);        
  rtems_disk_device *dd = NULL;                                       
  char *alloc_name = NULL;                                            
                                                                      
  if (dd_entry == NULL) {                                             
    return RTEMS_NO_MEMORY;                                           
 20037bc:	82 10 20 1a 	mov  0x1a, %g1                                 
  *dd_entry = dd;                                                     
  *dd_ptr = dd;                                                       
  *alloc_name_ptr = alloc_name;                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20037c0:	81 c7 e0 08 	ret                                            
 20037c4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200490c <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)
 200490c:	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)   
 2004910:	90 10 20 01 	mov  1, %o0                                    
 *      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)   
 2004914:	b8 10 00 18 	mov  %i0, %i4                                  
    if (new_part_desc == NULL)                                        
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    *new_part_desc = NULL;                                            
 2004918:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
 200491c:	92 10 20 28 	mov  0x28, %o1                                 
 2004920:	40 00 03 06 	call  2005538 <calloc>                         
 2004924:	b0 10 20 1a 	mov  0x1a, %i0                                 
 2004928:	80 a2 20 00 	cmp  %o0, 0                                    
 200492c:	02 80 00 27 	be  20049c8 <data_to_part_desc.part.1+0xbc>    <== NEVER TAKEN
 2004930:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
 2004934:	c2 0f 00 00 	ldub  [ %i4 ], %g1                             
    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));
 2004938:	92 07 20 08 	add  %i4, 8, %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);
 200493c:	c2 2a 00 00 	stb  %g1, [ %o0 ]                              
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
 2004940:	f6 0f 20 04 	ldub  [ %i4 + 4 ], %i3                         
                                                                      
    /* 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));
 2004944:	94 10 20 04 	mov  4, %o2                                    
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
 2004948:	f6 2a 20 01 	stb  %i3, [ %o0 + 1 ]                          
                                                                      
    /* 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));
 200494c:	40 00 43 49 	call  2015670 <memcpy>                         
 2004950:	90 07 bf fc 	add  %fp, -4, %o0                              
    part_desc->start = LE_TO_CPU_U32(temp);                           
 2004954:	7f ff ff ac 	call  2004804 <CPU_swap_u32>                   
 2004958:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                                                                      
    memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
 200495c:	92 07 20 0c 	add  %i4, 0xc, %o1                             
                                                                      
    /* 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);                           
 2004960:	d0 27 60 04 	st  %o0, [ %i5 + 4 ]                           
                                                                      
    memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
 2004964:	94 10 20 04 	mov  4, %o2                                    
 2004968:	40 00 43 42 	call  2015670 <memcpy>                         
 200496c:	90 07 bf fc 	add  %fp, -4, %o0                              
    part_desc->size = LE_TO_CPU_U32(temp);                            
 2004970:	7f ff ff a5 	call  2004804 <CPU_swap_u32>                   
 2004974:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 2004978:	d0 27 60 08 	st  %o0, [ %i5 + 8 ]                           
     * use partitions that are                                        
     * - extended                                                     
     * or                                                             
     * - FAT type and non-zero                                        
     */                                                               
    if (is_extended(part_desc->sys_type) ||                           
 200497c:	82 0e e0 7f 	and  %i3, 0x7f, %g1                            
 2004980:	80 a0 60 05 	cmp  %g1, 5                                    
 2004984:	02 80 00 0c 	be  20049b4 <data_to_part_desc.part.1+0xa8>    
 2004988:	b8 10 00 08 	mov  %o0, %i4                                  
    DOS_P32MB_PARTITION,                                              
    FAT32_PARTITION    ,FAT32_LBA_PARTITION,                          
    FAT16_LBA_PARTITION                                               
  };                                                                  
                                                                      
  return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
 200498c:	11 00 80 90 	sethi  %hi(0x2024000), %o0                     
 2004990:	92 0e e0 ff 	and  %i3, 0xff, %o1                            
 2004994:	90 12 23 38 	or  %o0, 0x338, %o0                            
 2004998:	40 00 42 c8 	call  20154b8 <memchr>                         
 200499c:	94 10 20 06 	mov  6, %o2                                    
     * use partitions that are                                        
     * - extended                                                     
     * or                                                             
     * - FAT type and non-zero                                        
     */                                                               
    if (is_extended(part_desc->sys_type) ||                           
 20049a0:	80 a2 20 00 	cmp  %o0, 0                                    
 20049a4:	02 80 00 06 	be  20049bc <data_to_part_desc.part.1+0xb0>    
 20049a8:	80 a7 20 00 	cmp  %i4, 0                                    
       ((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
 20049ac:	02 80 00 04 	be  20049bc <data_to_part_desc.part.1+0xb0>    <== NEVER TAKEN
 20049b0:	01 00 00 00 	nop                                            
      *new_part_desc = part_desc;                                     
 20049b4:	10 80 00 04 	b  20049c4 <data_to_part_desc.part.1+0xb8>     
 20049b8:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    }                                                                 
    else {                                                            
      /* empty partition */                                           
      free(part_desc);                                                
 20049bc:	40 00 03 b3 	call  2005888 <free>                           
 20049c0:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
 20049c4:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 20049c8:	81 c7 e0 08 	ret                                            
 20049cc:	81 e8 00 00 	restore                                        
                                                                      

02002a3c <devFS_Show>: #endif #include "devfs.h" void devFS_Show(void) {
 2002a3c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
 2002a40:	03 00 80 68 	sethi  %hi(0x201a000), %g1                     
 2002a44:	c2 00 60 84 	ld  [ %g1 + 0x84 ], %g1	! 201a084 <rtems_current_user_env>
                                                                      
  if (rootloc->mt_entry->ops == &devFS_ops) {                         
 2002a48:	05 00 80 61 	sethi  %hi(0x2018400), %g2                     
 2002a4c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 2002a50:	84 10 a0 ec 	or  %g2, 0xec, %g2                             
 2002a54:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
 2002a58:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
 2002a5c:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2002a60:	12 80 00 25 	bne  2002af4 <devFS_Show+0xb8>                 <== NEVER TAKEN
 2002a64:	33 00 80 61 	sethi  %hi(0x2018400), %i1                     
                                                                      
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;       
 2002a68:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
        for (j = 0; j < m; ++j) {                                     
          printk("%c", current->name [j]);                            
 2002a6c:	31 00 80 61 	sethi  %hi(0x2018400), %i0                     
        }                                                             
        printk(                                                       
 2002a70:	21 00 80 61 	sethi  %hi(0x2018400), %l0                     
  rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
                                                                      
  if (rootloc->mt_entry->ops == &devFS_ops) {                         
    const devFS_data *data = devFS_get_data(rootloc);                 
    size_t i = 0;                                                     
    size_t n = data->count;                                           
 2002a74:	f4 00 60 04 	ld  [ %g1 + 4 ], %i2                           
 2002a78:	fa 00 40 00 	ld  [ %g1 ], %i5                               
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
 2002a7c:	b6 10 20 00 	clr  %i3                                       
                                                                      
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
 2002a80:	b2 16 61 40 	or  %i1, 0x140, %i1                            
        for (j = 0; j < m; ++j) {                                     
          printk("%c", current->name [j]);                            
 2002a84:	b0 16 21 48 	or  %i0, 0x148, %i0                            
    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) {                                         
 2002a88:	10 80 00 18 	b  2002ae8 <devFS_Show+0xac>                   
 2002a8c:	a0 14 21 50 	or  %l0, 0x150, %l0                            
      devFS_node *current = nodes + i;                                
                                                                      
      if (current->name != NULL) {                                    
 2002a90:	80 a0 60 00 	cmp  %g1, 0                                    
 2002a94:	22 80 00 14 	be,a   2002ae4 <devFS_Show+0xa8>               
 2002a98:	b6 06 e0 01 	inc  %i3                                       
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
 2002a9c:	e2 07 60 04 	ld  [ %i5 + 4 ], %l1                           
                                                                      
        printk("/");                                                  
 2002aa0:	90 10 00 19 	mov  %i1, %o0                                  
 2002aa4:	40 00 04 94 	call  2003cf4 <printk>                         
 2002aa8:	b8 10 20 00 	clr  %i4                                       
        for (j = 0; j < m; ++j) {                                     
 2002aac:	10 80 00 07 	b  2002ac8 <devFS_Show+0x8c>                   
 2002ab0:	80 a7 00 11 	cmp  %i4, %l1                                  
          printk("%c", current->name [j]);                            
 2002ab4:	90 10 00 18 	mov  %i0, %o0                                  
 2002ab8:	d2 48 40 1c 	ldsb  [ %g1 + %i4 ], %o1                       
 2002abc:	40 00 04 8e 	call  2003cf4 <printk>                         
 2002ac0:	b8 07 20 01 	inc  %i4                                       
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
        for (j = 0; j < m; ++j) {                                     
 2002ac4:	80 a7 00 11 	cmp  %i4, %l1                                  
 2002ac8:	32 bf ff fb 	bne,a   2002ab4 <devFS_Show+0x78>              
 2002acc:	c2 07 40 00 	ld  [ %i5 ], %g1                               
          printk("%c", current->name [j]);                            
        }                                                             
        printk(                                                       
 2002ad0:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
 2002ad4:	d4 07 60 0c 	ld  [ %i5 + 0xc ], %o2                         
 2002ad8:	40 00 04 87 	call  2003cf4 <printk>                         
 2002adc:	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) {                                         
 2002ae0:	b6 06 e0 01 	inc  %i3                                       
 2002ae4:	ba 07 60 14 	add  %i5, 0x14, %i5                            
 2002ae8:	80 a6 c0 1a 	cmp  %i3, %i2                                  
 2002aec:	32 bf ff e9 	bne,a   2002a90 <devFS_Show+0x54>              
 2002af0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 2002af4:	81 c7 e0 08 	ret                                            
 2002af8:	81 e8 00 00 	restore                                        
                                                                      

0200bbec <devFS_eval_path>: } void devFS_eval_path( rtems_filesystem_eval_path_context_t *ctx ) {
 200bbec:	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;       
 200bbf0:	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;                                                   
 200bbf4:	f2 06 00 00 	ld  [ %i0 ], %i1                               
 200bbf8:	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;                                                
 200bbfc:	f6 06 20 04 	ld  [ %i0 + 4 ], %i3                           
  size_t pathlen,                                                     
  devFS_node **free_node_ptr                                          
)                                                                     
{                                                                     
  size_t i = 0;                                                       
  size_t n = data->count;                                             
 200bc00:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
 200bc04:	fa 00 40 00 	ld  [ %g1 ], %i5                               
  devFS_node *nodes = data->nodes;                                    
  devFS_node *node = NULL;                                            
 200bc08:	b8 10 20 00 	clr  %i4                                       
  devFS_node *free_node = NULL;                                       
 200bc0c:	82 10 20 00 	clr  %g1                                       
                                                                      
  for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {    
 200bc10:	10 80 00 12 	b  200bc58 <devFS_eval_path+0x6c>              
 200bc14:	b4 10 20 00 	clr  %i2                                       
    devFS_node *current = nodes + i;                                  
                                                                      
    if (current->name != NULL) {                                      
 200bc18:	80 a2 20 00 	cmp  %o0, 0                                    
 200bc1c:	02 80 00 0c 	be  200bc4c <devFS_eval_path+0x60>             
 200bc20:	a0 10 00 1d 	mov  %i5, %l0                                  
      if (                                                            
 200bc24:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
 200bc28:	80 a0 80 1b 	cmp  %g2, %i3                                  
 200bc2c:	12 80 00 08 	bne  200bc4c <devFS_eval_path+0x60>            
 200bc30:	a0 10 00 01 	mov  %g1, %l0                                  
        current->namelen == pathlen                                   
          && memcmp(current->name, path, pathlen) == 0                
 200bc34:	92 10 00 19 	mov  %i1, %o1                                  
 200bc38:	40 00 0d 82 	call  200f240 <memcmp>                         
 200bc3c:	94 10 00 1b 	mov  %i3, %o2                                  
 200bc40:	80 a2 20 00 	cmp  %o0, 0                                    
 200bc44:	22 80 00 02 	be,a   200bc4c <devFS_eval_path+0x60>          
 200bc48:	b8 10 00 1d 	mov  %i5, %i4                                  
  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) {    
 200bc4c:	b4 06 a0 01 	inc  %i2                                       
 200bc50:	ba 07 60 14 	add  %i5, 0x14, %i5                            
 200bc54:	82 10 00 10 	mov  %l0, %g1                                  
 200bc58:	80 a7 20 00 	cmp  %i4, 0                                    
 200bc5c:	02 80 00 0a 	be  200bc84 <devFS_eval_path+0x98>             
 200bc60:	80 a6 80 11 	cmp  %i2, %l1                                  
 200bc64:	80 a0 60 00 	cmp  %g1, 0                                    
 200bc68:	02 80 00 07 	be  200bc84 <devFS_eval_path+0x98>             
 200bc6c:	80 a6 80 11 	cmp  %i2, %l1                                  
    rtems_filesystem_eval_path_get_pathlen(ctx),                      
    &free_node                                                        
  );                                                                  
  int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);         
                                                                      
  if (node != NULL) {                                                 
 200bc70:	80 a7 20 00 	cmp  %i4, 0                                    
 200bc74:	12 80 00 08 	bne  200bc94 <devFS_eval_path+0xa8>            
 200bc78:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
      rtems_filesystem_eval_path_clear_path(ctx);                     
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, EEXIST);                  
    }                                                                 
  } else {                                                            
    if ((eval_flags & RTEMS_FS_MAKE) != 0) {                          
 200bc7c:	10 80 00 0b 	b  200bca8 <devFS_eval_path+0xbc>              
 200bc80:	80 88 a0 20 	btst  0x20, %g2                                
  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) {    
 200bc84:	32 bf ff e5 	bne,a   200bc18 <devFS_eval_path+0x2c>         
 200bc88:	d0 07 40 00 	ld  [ %i5 ], %o0                               
    rtems_filesystem_eval_path_get_pathlen(ctx),                      
    &free_node                                                        
  );                                                                  
  int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);         
                                                                      
  if (node != NULL) {                                                 
 200bc8c:	10 bf ff fa 	b  200bc74 <devFS_eval_path+0x88>              
 200bc90:	80 a7 20 00 	cmp  %i4, 0                                    
    if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {                     
 200bc94:	80 88 a0 40 	btst  0x40, %g2                                
 200bc98:	12 80 00 12 	bne  200bce0 <devFS_eval_path+0xf4>            
 200bc9c:	b2 10 20 11 	mov  0x11, %i1                                 
      currentloc->node_access = node;                                 
 200bca0:	10 80 00 0a 	b  200bcc8 <devFS_eval_path+0xdc>              
 200bca4:	f8 26 20 20 	st  %i4, [ %i0 + 0x20 ]                        
      rtems_filesystem_eval_path_clear_path(ctx);                     
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, EEXIST);                  
    }                                                                 
  } else {                                                            
    if ((eval_flags & RTEMS_FS_MAKE) != 0) {                          
 200bca8:	02 80 00 0d 	be  200bcdc <devFS_eval_path+0xf0>             <== NEVER TAKEN
 200bcac:	80 a0 60 00 	cmp  %g1, 0                                    
      if (free_node != NULL) {                                        
 200bcb0:	02 80 00 09 	be  200bcd4 <devFS_eval_path+0xe8>             
 200bcb4:	84 10 21 ff 	mov  0x1ff, %g2                                
        free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;                
 200bcb8:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
        currentloc->node_access = free_node;                          
 200bcbc:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  ctx->token = token;                                                 
 200bcc0:	f2 26 20 08 	st  %i1, [ %i0 + 8 ]                           
  ctx->tokenlen = tokenlen;                                           
 200bcc4:	f6 26 20 0c 	st  %i3, [ %i0 + 0xc ]                         
                                                                      
static inline void rtems_filesystem_eval_path_clear_path(             
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->pathlen = 0;                                                   
 200bcc8:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
 200bccc:	81 c7 e0 08 	ret                                            
 200bcd0:	81 e8 00 00 	restore                                        
          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);                
 200bcd4:	10 80 00 03 	b  200bce0 <devFS_eval_path+0xf4>              
 200bcd8:	b2 10 20 1c 	mov  0x1c, %i1                                 
      }                                                               
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, ENOENT);                  
 200bcdc:	b2 10 20 02 	mov  2, %i1                                    <== NOT EXECUTED
 200bce0:	7f ff e3 de 	call  2004c58 <rtems_filesystem_eval_path_error>
 200bce4:	81 e8 00 00 	restore                                        
                                                                      

020035fc <devFS_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
 20035fc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
 2003600:	80 a6 a0 03 	cmp  %i2, 3                                    
 2003604:	12 80 00 0e 	bne  200363c <devFS_mknod+0x40>                
 2003608:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
 200360c:	c2 4e 40 00 	ldsb  [ %i1 ], %g1                             
 2003610:	80 a0 60 64 	cmp  %g1, 0x64                                 
 2003614:	12 80 00 0b 	bne  2003640 <devFS_mknod+0x44>                <== NEVER TAKEN
 2003618:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
 200361c:	c2 4e 60 01 	ldsb  [ %i1 + 1 ], %g1                         
 2003620:	80 a0 60 65 	cmp  %g1, 0x65                                 
 2003624:	12 80 00 07 	bne  2003640 <devFS_mknod+0x44>                <== NEVER TAKEN
 2003628:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
 200362c:	c2 4e 60 02 	ldsb  [ %i1 + 2 ], %g1                         
 2003630:	80 a0 60 76 	cmp  %g1, 0x76                                 
 2003634:	02 80 00 1b 	be  20036a0 <devFS_mknod+0xa4>                 <== ALWAYS TAKEN
 2003638:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
    if (S_ISBLK(mode) || S_ISCHR(mode)) {                             
 200363c:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
 2003640:	84 0e c0 02 	and  %i3, %g2, %g2                             
 2003644:	80 a0 80 01 	cmp  %g2, %g1                                  
 2003648:	12 80 00 1b 	bne  20036b4 <devFS_mknod+0xb8>                
 200364c:	01 00 00 00 	nop                                            
      char *dupname = malloc(namelen);                                
 2003650:	40 00 01 e6 	call  2003de8 <malloc>                         
 2003654:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      if (dupname != NULL) {                                          
 2003658:	84 92 20 00 	orcc  %o0, 0, %g2                              
 200365c:	02 80 00 0d 	be  2003690 <devFS_mknod+0x94>                 
 2003660:	92 10 00 19 	mov  %i1, %o1                                  
        devFS_node *node = parentloc->node_access;                    
 2003664:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
                                                                      
        node->name = dupname;                                         
 2003668:	c4 20 40 00 	st  %g2, [ %g1 ]                               
        node->namelen = namelen;                                      
 200366c:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
        node->major = rtems_filesystem_dev_major_t(dev);              
 2003670:	f8 20 60 08 	st  %i4, [ %g1 + 8 ]                           
        node->minor = rtems_filesystem_dev_minor_t(dev);              
 2003674:	fa 20 60 0c 	st  %i5, [ %g1 + 0xc ]                         
        node->mode = mode;                                            
 2003678:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
        memcpy(dupname, name, namelen);                               
 200367c:	94 10 00 1a 	mov  %i2, %o2                                  
 2003680:	40 00 2f 1a 	call  200f2e8 <memcpy>                         
 2003684:	b0 10 20 00 	clr  %i0                                       
 2003688:	81 c7 e0 08 	ret                                            
 200368c:	81 e8 00 00 	restore                                        
      } else {                                                        
        errno = ENOMEM;                                               
 2003690:	40 00 2b 11 	call  200e2d4 <__errno>                        
 2003694:	01 00 00 00 	nop                                            
 2003698:	10 80 00 0a 	b  20036c0 <devFS_mknod+0xc4>                  
 200369c:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
    } else {                                                          
      errno = ENOTSUP;                                                
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    if (!S_ISDIR(mode)) {                                             
 20036a0:	b6 0e c0 01 	and  %i3, %g1, %i3                             
 20036a4:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 20036a8:	80 a6 c0 01 	cmp  %i3, %g1                                  
 20036ac:	02 bf ff f7 	be  2003688 <devFS_mknod+0x8c>                 <== ALWAYS TAKEN
 20036b0:	b0 10 20 00 	clr  %i0                                       
      errno = ENOTSUP;                                                
 20036b4:	40 00 2b 08 	call  200e2d4 <__errno>                        
 20036b8:	01 00 00 00 	nop                                            
 20036bc:	82 10 20 86 	mov  0x86, %g1	! 86 <PROM_START+0x86>          
 20036c0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      rv = -1;                                                        
 20036c4:	b0 10 3f ff 	mov  -1, %i0                                   
    }                                                                 
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 20036c8:	81 c7 e0 08 	ret                                            
 20036cc:	81 e8 00 00 	restore                                        
                                                                      

020035b4 <disk_lock>: */ static volatile bool diskdevs_protected; static rtems_status_code disk_lock(void) {
 20035b4:	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);
 20035b8:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 20035bc:	d0 00 61 2c 	ld  [ %g1 + 0x12c ], %o0	! 202152c <diskdevs_mutex>
 20035c0:	92 10 20 00 	clr  %o1                                       
 20035c4:	94 10 20 00 	clr  %o2                                       
 20035c8:	40 00 15 4c 	call  2008af8 <rtems_semaphore_obtain>         
 20035cc:	b0 10 20 16 	mov  0x16, %i0                                 
  if (sc == RTEMS_SUCCESSFUL) {                                       
 20035d0:	80 a2 20 00 	cmp  %o0, 0                                    
 20035d4:	12 80 00 05 	bne  20035e8 <disk_lock+0x34>                  <== NEVER TAKEN
 20035d8:	84 10 20 01 	mov  1, %g2                                    
    diskdevs_protected = true;                                        
 20035dc:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
                                                                      
    return RTEMS_SUCCESSFUL;                                          
 20035e0:	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;                                        
 20035e4:	c4 28 61 28 	stb  %g2, [ %g1 + 0x128 ]                      
                                                                      
    return RTEMS_SUCCESSFUL;                                          
  } else {                                                            
    return RTEMS_NOT_CONFIGURED;                                      
  }                                                                   
}                                                                     
 20035e8:	81 c7 e0 08 	ret                                            
 20035ec:	81 e8 00 00 	restore                                        
                                                                      

020035f0 <disk_unlock>: static void disk_unlock(void) {
 20035f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
 20035f4:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 20035f8:	c0 28 61 28 	clrb  [ %g1 + 0x128 ]	! 2021528 <diskdevs_protected>
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
 20035fc:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 2003600:	40 00 15 87 	call  2008c1c <rtems_semaphore_release>        
 2003604:	d0 00 61 2c 	ld  [ %g1 + 0x12c ], %o0	! 202152c <diskdevs_mutex>
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003608:	80 a2 20 00 	cmp  %o0, 0                                    
 200360c:	02 80 00 04 	be  200361c <disk_unlock+0x2c>                 <== ALWAYS TAKEN
 2003610:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
    /* FIXME: Error number */                                         
    rtems_fatal_error_occurred(0xdeadbeef);                           
 2003614:	40 00 16 fe 	call  200920c <rtems_fatal_error_occurred>     <== NOT EXECUTED
 2003618:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
 200361c:	81 c7 e0 08 	ret                                            
 2003620:	81 e8 00 00 	restore                                        
                                                                      

02005124 <drainOutput.part.0>: /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty)
 2005124:	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);                                  
 2005128:	7f ff f5 27 	call  20025c4 <sparc_disable_interrupts>       
 200512c:	01 00 00 00 	nop                                            
    while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {              
      tty->rawOutBufState = rob_wait;                                 
 2005130:	10 80 00 0f 	b  200516c <drainOutput.part.0+0x48>           
 2005134:	b8 10 20 02 	mov  2, %i4	! 2 <PROM_START+0x2>               
      rtems_interrupt_enable (level);                                 
 2005138:	7f ff f5 27 	call  20025d4 <sparc_enable_interrupts>        <== NOT EXECUTED
 200513c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      sc = rtems_semaphore_obtain(                                    
 2005140:	d0 06 20 8c 	ld  [ %i0 + 0x8c ], %o0                        <== NOT EXECUTED
 2005144:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2005148:	40 00 09 5f 	call  20076c4 <rtems_semaphore_obtain>         <== NOT EXECUTED
 200514c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
 2005150:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2005154:	02 80 00 04 	be  2005164 <drainOutput.part.0+0x40>          <== NOT EXECUTED
 2005158:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
 200515c:	40 00 0b 37 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 2005160:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_interrupt_disable (level);                                
 2005164:	7f ff f5 18 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2005168:	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) {              
 200516c:	c4 06 20 84 	ld  [ %i0 + 0x84 ], %g2                        
 2005170:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
 2005174:	80 a0 80 01 	cmp  %g2, %g1                                  
 2005178:	32 bf ff f0 	bne,a   2005138 <drainOutput.part.0+0x14>      <== NEVER TAKEN
 200517c:	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);                                   
 2005180:	7f ff f5 15 	call  20025d4 <sparc_enable_interrupts>        
 2005184:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

02003a40 <dup2>: */ int dup2( int fildes, int fildes2 ) {
 2003a40:	9d e3 bf 58 	save  %sp, -168, %sp                           
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
 2003a44:	90 10 00 18 	mov  %i0, %o0                                  
 2003a48:	40 00 01 e2 	call  20041d0 <fstat>                          
 2003a4c:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( status == -1 )                                                 
 2003a50:	80 a2 3f ff 	cmp  %o0, -1                                   
 2003a54:	12 80 00 04 	bne  2003a64 <dup2+0x24>                       
 2003a58:	90 10 00 19 	mov  %i1, %o0                                  
    return -1;                                                        
 2003a5c:	81 c7 e0 08 	ret                                            
 2003a60:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      
  /*                                                                  
   *  If fildes2 is not valid, then we should not do anything either. 
   */                                                                 
                                                                      
  status = fstat( fildes2, &buf );                                    
 2003a64:	40 00 01 db 	call  20041d0 <fstat>                          
 2003a68:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( status == -1 )                                                 
 2003a6c:	80 a2 3f ff 	cmp  %o0, -1                                   
 2003a70:	02 bf ff fb 	be  2003a5c <dup2+0x1c>                        <== NEVER TAKEN
 2003a74:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
 2003a78:	92 10 20 00 	clr  %o1                                       
 2003a7c:	40 00 00 af 	call  2003d38 <fcntl>                          
 2003a80:	94 10 00 19 	mov  %i1, %o2                                  
}                                                                     
 2003a84:	81 c7 e0 08 	ret                                            
 2003a88:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

02005f10 <echo>: /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) {
 2005f10:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
 2005f14:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
 2005f18:	80 88 62 00 	btst  0x200, %g1                               
 2005f1c:	02 80 00 19 	be  2005f80 <echo+0x70>                        <== NEVER TAKEN
 2005f20:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
 2005f24:	c2 00 60 58 	ld  [ %g1 + 0x58 ], %g1	! 201cc58 <__ctype_ptr__>
 2005f28:	82 00 40 18 	add  %g1, %i0, %g1                             
 2005f2c:	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) &&                             
 2005f30:	80 88 60 20 	btst  0x20, %g1                                
 2005f34:	02 80 00 14 	be  2005f84 <echo+0x74>                        
 2005f38:	90 10 00 18 	mov  %i0, %o0                                  
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
 2005f3c:	82 06 3f f7 	add  %i0, -9, %g1                              
 2005f40:	82 08 60 ff 	and  %g1, 0xff, %g1                            
 2005f44:	80 a0 60 01 	cmp  %g1, 1                                    
 2005f48:	08 80 00 0f 	bleu  2005f84 <echo+0x74>                      
 2005f4c:	82 10 20 5e 	mov  0x5e, %g1                                 
    char echobuf[2];                                                  
                                                                      
    echobuf[0] = '^';                                                 
    echobuf[1] = c ^ 0x40;                                            
 2005f50:	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] = '^';                                                 
 2005f54:	c2 2f bf f8 	stb  %g1, [ %fp + -8 ]                         
    echobuf[1] = c ^ 0x40;                                            
 2005f58:	f0 2f bf f9 	stb  %i0, [ %fp + -7 ]                         
    rtems_termios_puts (echobuf, 2, tty);                             
 2005f5c:	90 07 bf f8 	add  %fp, -8, %o0                              
 2005f60:	92 10 20 02 	mov  2, %o1                                    
 2005f64:	7f ff ff 43 	call  2005c70 <rtems_termios_puts>             
 2005f68:	94 10 00 19 	mov  %i1, %o2                                  
    tty->column += 2;                                                 
 2005f6c:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
 2005f70:	82 00 60 02 	add  %g1, 2, %g1                               
 2005f74:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
 2005f78:	81 c7 e0 08 	ret                                            
 2005f7c:	81 e8 00 00 	restore                                        
  } else {                                                            
    oproc (c, tty);                                                   
 2005f80:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2005f84:	7f ff ff 84 	call  2005d94 <oproc>                          
 2005f88:	92 10 00 19 	mov  %i1, %o1                                  
 2005f8c:	81 c7 e0 08 	ret                                            
 2005f90:	81 e8 00 00 	restore                                        
                                                                      

02024824 <endgrent>: } void endgrent(void) { if (group_fp != NULL)
 2024824:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 2024828:	d0 00 62 88 	ld  [ %g1 + 0x288 ], %o0	! 2061a88 <group_fp>  
 202482c:	80 a2 20 00 	cmp  %o0, 0                                    
 2024830:	02 80 00 05 	be  2024844 <endgrent+0x20>                    <== NEVER TAKEN
 2024834:	01 00 00 00 	nop                                            
    fclose(group_fp);                                                 
 2024838:	82 13 c0 00 	mov  %o7, %g1                                  
 202483c:	40 00 48 d8 	call  2036b9c <fclose>                         
 2024840:	9e 10 40 00 	mov  %g1, %o7                                  
 2024844:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

02024680 <endpwent>: } void endpwent(void) { if (passwd_fp != NULL)
 2024680:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 2024684:	d0 00 61 a8 	ld  [ %g1 + 0x1a8 ], %o0	! 20619a8 <passwd_fp> 
 2024688:	80 a2 20 00 	cmp  %o0, 0                                    
 202468c:	02 80 00 05 	be  20246a0 <endpwent+0x20>                    <== NEVER TAKEN
 2024690:	01 00 00 00 	nop                                            
    fclose(passwd_fp);                                                
 2024694:	82 13 c0 00 	mov  %o7, %g1                                  
 2024698:	40 00 49 41 	call  2036b9c <fclose>                         
 202469c:	9e 10 40 00 	mov  %g1, %o7                                  
 20246a0:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

02005f94 <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)
 2005f94:	9d e3 bf a0 	save  %sp, -96, %sp                            
          rtems_termios_puts ("\b \b", 3, tty);                       
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
          rtems_termios_puts ("\b \b", 3, tty);                       
 2005f98:	35 00 80 6c 	sethi  %hi(0x201b000), %i2                     
 * 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)                   
 2005f9c:	ba 10 00 18 	mov  %i0, %i5                                  
 2005fa0:	37 00 80 73 	sethi  %hi(0x201cc00), %i3                     
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
          rtems_termios_puts ("\b", 1, tty);                          
 2005fa4:	31 00 80 6c 	sethi  %hi(0x201b000), %i0                     
          rtems_termios_puts ("\b \b", 3, tty);                       
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
          rtems_termios_puts ("\b \b", 3, tty);                       
 2005fa8:	b4 16 a3 b8 	or  %i2, 0x3b8, %i2                            
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
          rtems_termios_puts ("\b", 1, tty);                          
 2005fac:	10 80 00 62 	b  2006134 <erase.part.2+0x1a0>                
 2005fb0:	b0 16 23 b0 	or  %i0, 0x3b0, %i0                            
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
 2005fb4:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
 2005fb8:	86 00 ff ff 	add  %g3, -1, %g3                              
 2005fbc:	c6 27 60 20 	st  %g3, [ %i5 + 0x20 ]                        
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
 2005fc0:	80 88 60 08 	btst  8, %g1                                   
 2005fc4:	02 80 00 59 	be  2006128 <erase.part.2+0x194>               <== NEVER TAKEN
 2005fc8:	f8 09 00 03 	ldub  [ %g4 + %g3 ], %i4                       
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
 2005fcc:	80 a6 60 00 	cmp  %i1, 0                                    
 2005fd0:	32 80 00 08 	bne,a   2005ff0 <erase.part.2+0x5c>            
 2005fd4:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
 2005fd8:	80 88 60 10 	btst  0x10, %g1                                
 2005fdc:	32 80 00 05 	bne,a   2005ff0 <erase.part.2+0x5c>            <== ALWAYS TAKEN
 2005fe0:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
        echo (tty->termios.c_cc[VERASE], tty);                        
 2005fe4:	f0 0f 60 43 	ldub  [ %i5 + 0x43 ], %i0                      <== NOT EXECUTED
 2005fe8:	7f ff ff ca 	call  2005f10 <echo>                           <== NOT EXECUTED
 2005fec:	93 e8 00 1d 	restore  %g0, %i5, %o1                         <== NOT EXECUTED
      } else if (c == '\t') {                                         
 2005ff0:	80 a7 20 09 	cmp  %i4, 9                                    
 2005ff4:	32 80 00 28 	bne,a   2006094 <erase.part.2+0x100>           
 2005ff8:	c4 06 e0 58 	ld  [ %i3 + 0x58 ], %g2                        
        int col = tty->read_start_column;                             
 2005ffc:	f8 07 60 2c 	ld  [ %i5 + 0x2c ], %i4                        
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
 2006000:	da 06 e0 58 	ld  [ %i3 + 0x58 ], %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;                                                    
 2006004:	84 10 20 00 	clr  %g2                                       
        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)                       
 2006008:	10 80 00 12 	b  2006050 <erase.part.2+0xbc>                 
 200600c:	82 08 62 00 	and  %g1, 0x200, %g1                           
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
 2006010:	80 a3 e0 09 	cmp  %o7, 9                                    
 2006014:	12 80 00 04 	bne  2006024 <erase.part.2+0x90>               
 2006018:	84 00 a0 01 	inc  %g2                                       
            col = (col | 7) + 1;                                      
 200601c:	10 80 00 0c 	b  200604c <erase.part.2+0xb8>                 
 2006020:	b8 17 20 07 	or  %i4, 7, %i4                                
          } else if (iscntrl (c)) {                                   
 2006024:	9e 03 40 0f 	add  %o5, %o7, %o7                             
 2006028:	de 0b e0 01 	ldub  [ %o7 + 1 ], %o7                         
 200602c:	80 8b e0 20 	btst  0x20, %o7                                
 2006030:	22 80 00 08 	be,a   2006050 <erase.part.2+0xbc>             <== ALWAYS TAKEN
 2006034:	b8 07 20 01 	inc  %i4                                       
            if (tty->termios.c_lflag & ECHOCTL)                       
 2006038:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 200603c:	32 80 00 05 	bne,a   2006050 <erase.part.2+0xbc>            <== NOT EXECUTED
 2006040:	b8 07 20 02 	add  %i4, 2, %i4                               <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
 2006044:	10 80 00 04 	b  2006054 <erase.part.2+0xc0>                 <== NOT EXECUTED
 2006048:	80 a0 80 03 	cmp  %g2, %g3                                  <== NOT EXECUTED
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
            if (tty->termios.c_lflag & ECHOCTL)                       
              col += 2;                                               
          } else {                                                    
            col++;                                                    
 200604c:	b8 07 20 01 	inc  %i4                                       
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
 2006050:	80 a0 80 03 	cmp  %g2, %g3                                  
 2006054:	32 bf ff ef 	bne,a   2006010 <erase.part.2+0x7c>            
 2006058:	de 09 00 02 	ldub  [ %g4 + %g2 ], %o7                       
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
 200605c:	10 80 00 09 	b  2006080 <erase.part.2+0xec>                 
 2006060:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
          rtems_termios_puts ("\b", 1, tty);                          
 2006064:	92 10 20 01 	mov  1, %o1                                    
 2006068:	7f ff ff 02 	call  2005c70 <rtems_termios_puts>             
 200606c:	94 10 00 1d 	mov  %i5, %o2                                  
          tty->column--;                                              
 2006070:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 2006074:	82 00 7f ff 	add  %g1, -1, %g1                              
 2006078:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
 200607c:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 2006080:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2006084:	14 bf ff f8 	bg  2006064 <erase.part.2+0xd0>                
 2006088:	90 10 00 18 	mov  %i0, %o0                                  
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
 200608c:	10 80 00 28 	b  200612c <erase.part.2+0x198>                
 2006090:	80 a6 60 00 	cmp  %i1, 0                                    
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
 2006094:	b8 07 20 01 	inc  %i4                                       
 2006098:	c4 08 80 1c 	ldub  [ %g2 + %i4 ], %g2                       
 200609c:	80 88 a0 20 	btst  0x20, %g2                                
 20060a0:	22 80 00 10 	be,a   20060e0 <erase.part.2+0x14c>            <== ALWAYS TAKEN
 20060a4:	c2 06 e0 58 	ld  [ %i3 + 0x58 ], %g1                        
 20060a8:	80 88 62 00 	btst  0x200, %g1                               <== NOT EXECUTED
 20060ac:	02 80 00 0d 	be  20060e0 <erase.part.2+0x14c>               <== NOT EXECUTED
 20060b0:	c2 06 e0 58 	ld  [ %i3 + 0x58 ], %g1                        <== NOT EXECUTED
          rtems_termios_puts ("\b \b", 3, tty);                       
 20060b4:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 20060b8:	92 10 20 03 	mov  3, %o1                                    <== NOT EXECUTED
 20060bc:	7f ff fe ed 	call  2005c70 <rtems_termios_puts>             <== NOT EXECUTED
 20060c0:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
          if (tty->column)                                            
 20060c4:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        <== NOT EXECUTED
 20060c8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 20060cc:	22 80 00 05 	be,a   20060e0 <erase.part.2+0x14c>            <== NOT EXECUTED
 20060d0:	c2 06 e0 58 	ld  [ %i3 + 0x58 ], %g1                        <== NOT EXECUTED
            tty->column--;                                            
 20060d4:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
 20060d8:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        <== NOT EXECUTED
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
 20060dc:	c2 06 e0 58 	ld  [ %i3 + 0x58 ], %g1                        <== NOT EXECUTED
 20060e0:	c2 08 40 1c 	ldub  [ %g1 + %i4 ], %g1                       
 20060e4:	80 88 60 20 	btst  0x20, %g1                                
 20060e8:	02 80 00 07 	be  2006104 <erase.part.2+0x170>               <== ALWAYS TAKEN
 20060ec:	90 10 00 1a 	mov  %i2, %o0                                  
 20060f0:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
 20060f4:	80 88 62 00 	btst  0x200, %g1                               <== NOT EXECUTED
 20060f8:	02 80 00 0d 	be  200612c <erase.part.2+0x198>               <== NOT EXECUTED
 20060fc:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
          rtems_termios_puts ("\b \b", 3, tty);                       
 2006100:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 2006104:	92 10 20 03 	mov  3, %o1                                    
 2006108:	7f ff fe da 	call  2005c70 <rtems_termios_puts>             
 200610c:	94 10 00 1d 	mov  %i5, %o2                                  
          if (tty->column)                                            
 2006110:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 2006114:	80 a0 60 00 	cmp  %g1, 0                                    
 2006118:	02 80 00 05 	be  200612c <erase.part.2+0x198>               <== NEVER TAKEN
 200611c:	80 a6 60 00 	cmp  %i1, 0                                    
            tty->column--;                                            
 2006120:	82 00 7f ff 	add  %g1, -1, %g1                              
 2006124:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
 2006128:	80 a6 60 00 	cmp  %i1, 0                                    
 200612c:	02 80 00 06 	be  2006144 <erase.part.2+0x1b0>               
 2006130:	01 00 00 00 	nop                                            
        echo ('\n', tty);                                             
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
 2006134:	c6 07 60 20 	ld  [ %i5 + 0x20 ], %g3                        
 2006138:	80 a0 e0 00 	cmp  %g3, 0                                    
 200613c:	32 bf ff 9e 	bne,a   2005fb4 <erase.part.2+0x20>            
 2006140:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
 2006144:	81 c7 e0 08 	ret                                            
 2006148:	81 e8 00 00 	restore                                        
                                                                      

02004740 <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 ) {
 2004740:	9d e3 bf 98 	save  %sp, -104, %sp                           
  memset(ctx, 0, sizeof(*ctx));                                       
 2004744:	92 10 20 00 	clr  %o1                                       
 2004748:	90 10 00 18 	mov  %i0, %o0                                  
 200474c:	40 00 2e 56 	call  20100a4 <memset>                         
 2004750:	94 10 20 38 	mov  0x38, %o2                                 
                                                                      
  ctx->path = path;                                                   
 2004754:	f2 26 00 00 	st  %i1, [ %i0 ]                               
  ctx->pathlen = pathlen;                                             
 2004758:	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) {                                             
 200475c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2004760:	02 80 00 19 	be  20047c4 <eval_path_start+0x84>             
 2004764:	f6 26 20 10 	st  %i3, [ %i0 + 0x10 ]                        
    char c = ctx->path [0];                                           
 2004768:	f6 0e 40 00 	ldub  [ %i1 ], %i3                             
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
 200476c:	40 00 01 79 	call  2004d50 <rtems_filesystem_global_location_obtain>
 2004770:	90 10 00 1c 	mov  %i4, %o0                                  
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
 2004774:	83 2e e0 18 	sll  %i3, 0x18, %g1                            
 2004778:	83 38 60 18 	sra  %g1, 0x18, %g1                            
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
 200477c:	80 a0 60 5c 	cmp  %g1, 0x5c                                 
 2004780:	02 80 00 05 	be  2004794 <eval_path_start+0x54>             <== NEVER TAKEN
 2004784:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
 2004788:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
 200478c:	12 80 00 0a 	bne  20047b4 <eval_path_start+0x74>            
 2004790:	90 10 00 1d 	mov  %i5, %o0                                  
      ++ctx->path;                                                    
 2004794:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      --ctx->pathlen;                                                 
      ctx->startloc = rtems_filesystem_global_location_obtain(        
 2004798:	90 06 20 30 	add  %i0, 0x30, %o0                            
    char c = ctx->path [0];                                           
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
      ++ctx->path;                                                    
 200479c:	82 00 60 01 	inc  %g1                                       
 20047a0:	c2 26 00 00 	st  %g1, [ %i0 ]                               
      --ctx->pathlen;                                                 
 20047a4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 20047a8:	82 00 7f ff 	add  %g1, -1, %g1                              
 20047ac:	10 80 00 02 	b  20047b4 <eval_path_start+0x74>              
 20047b0:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
      ctx->startloc = rtems_filesystem_global_location_obtain(        
        &ctx->rootloc                                                 
      );                                                              
    } else {                                                          
      ctx->startloc = rtems_filesystem_global_location_obtain(        
 20047b4:	40 00 01 67 	call  2004d50 <rtems_filesystem_global_location_obtain>
 20047b8:	01 00 00 00 	nop                                            
 20047bc:	10 80 00 0d 	b  20047f0 <eval_path_start+0xb0>              
 20047c0:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
);                                                                    
                                                                      
static inline rtems_filesystem_global_location_t *                    
rtems_filesystem_global_location_obtain_null(void)                    
{                                                                     
  rtems_filesystem_global_location_t *global_loc = NULL;              
 20047c4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
 20047c8:	40 00 01 62 	call  2004d50 <rtems_filesystem_global_location_obtain>
 20047cc:	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;              
 20047d0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
        global_current_ptr                                            
      );                                                              
    }                                                                 
  } else {                                                            
    ctx->rootloc = rtems_filesystem_global_location_obtain_null();    
 20047d4:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
 20047d8:	40 00 01 5e 	call  2004d50 <rtems_filesystem_global_location_obtain>
 20047dc:	90 07 bf fc 	add  %fp, -4, %o0                              
    ctx->startloc = rtems_filesystem_global_location_obtain_null();   
    errno = ENOENT;                                                   
 20047e0:	40 00 2b a3 	call  200f66c <__errno>                        
 20047e4:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
 20047e8:	82 10 20 02 	mov  2, %g1                                    
 20047ec:	c2 22 00 00 	st  %g1, [ %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;
 20047f0:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
 20047f4:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
 20047f8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 20047fc:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 2004800:	9f c0 40 00 	call  %g1                                      
 2004804:	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(                                    
 2004808:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
 200480c:	40 00 1d 77 	call  200bde8 <rtems_filesystem_location_clone>
 2004810:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
 2004814:	90 10 00 18 	mov  %i0, %o0                                  
 2004818:	7f ff ff b0 	call  20046d8 <rtems_filesystem_eval_path_continue>
 200481c:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
 2004820:	81 c7 e0 08 	ret                                            
 2004824:	81 e8 00 00 	restore                                        
                                                                      

02012f44 <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) {
 2012f44:	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);
 2012f48:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
 2012f4c:	c4 0e 20 0c 	ldub  [ %i0 + 0xc ], %g2                       
 2012f50:	84 20 80 01 	sub  %g2, %g1, %g2                             
 2012f54:	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);
 2012f58:	b9 2f 40 02 	sll  %i5, %g2, %i4                             
 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 -                                                 
 2012f5c:	b8 26 40 1c 	sub  %i1, %i4, %i4                             
              fat_block_num_to_sector_num (fs_info,                   
                  fat_sector_num_to_block_num (fs_info, sector)))     
            << fs_info->vol.sec_log2);                                
 2012f60:	b9 2f 00 01 	sll  %i4, %g1, %i4                             
                                                         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)
 2012f64:	c2 0e 20 89 	ldub  [ %i0 + 0x89 ], %g1                      
 2012f68:	80 a0 60 00 	cmp  %g1, 0                                    
 2012f6c:	02 80 00 06 	be  2012f84 <fat_buf_access+0x40>              
 2012f70:	01 00 00 00 	nop                                            
 2012f74:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
 2012f78:	80 a0 40 19 	cmp  %g1, %i1                                  
 2012f7c:	22 80 00 1c 	be,a   2012fec <fat_buf_access+0xa8>           
 2012f80:	c2 06 20 8c 	ld  [ %i0 + 0x8c ], %g1                        
    {                                                                 
        fat_buf_release(fs_info);                                     
 2012f84:	7f ff ff 7c 	call  2012d74 <fat_buf_release>                
 2012f88:	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);
 2012f8c:	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)                              
 2012f90:	80 a6 a0 01 	cmp  %i2, 1                                    
 2012f94:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
 2012f98:	12 80 00 06 	bne  2012fb0 <fat_buf_access+0x6c>             
 2012f9c:	94 06 20 8c 	add  %i0, 0x8c, %o2                            
            sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
 2012fa0:	7f ff f7 ae 	call  2010e58 <rtems_bdbuf_read>               
 2012fa4:	01 00 00 00 	nop                                            
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
 2012fa8:	10 80 00 05 	b  2012fbc <fat_buf_access+0x78>               
 2012fac:	80 a2 20 00 	cmp  %o0, 0                                    
        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);
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
 2012fb0:	7f ff f7 79 	call  2010d94 <rtems_bdbuf_get>                
 2012fb4:	01 00 00 00 	nop                                            
        if (sc != RTEMS_SUCCESSFUL)                                   
 2012fb8:	80 a2 20 00 	cmp  %o0, 0                                    
 2012fbc:	02 80 00 08 	be  2012fdc <fat_buf_access+0x98>              <== ALWAYS TAKEN
 2012fc0:	82 10 20 01 	mov  1, %g1                                    
            rtems_set_errno_and_return_minus_one(EIO);                
 2012fc4:	40 00 21 7a 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2012fc8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012fcc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 2012fd0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2012fd4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012fd8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        fs_info->c.blk_num = sec_num;                                 
 2012fdc:	f2 26 20 84 	st  %i1, [ %i0 + 0x84 ]                        
        fs_info->c.modified = 0;                                      
 2012fe0:	c0 2e 20 88 	clrb  [ %i0 + 0x88 ]                           
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
 2012fe4:	c2 2e 20 89 	stb  %g1, [ %i0 + 0x89 ]                       
    }                                                                 
    *sec_buf = &fs_info->c.buf->buffer[blk_ofs];                      
 2012fe8:	c2 06 20 8c 	ld  [ %i0 + 0x8c ], %g1                        
 2012fec:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 2012ff0:	b8 00 40 1c 	add  %g1, %i4, %i4                             
 2012ff4:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
    return RC_OK;                                                     
}                                                                     
 2012ff8:	81 c7 e0 08 	ret                                            
 2012ffc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02012d74 <fat_buf_release>: return RC_OK; } int fat_buf_release(fat_fs_info_t *fs_info) {
 2012d74:	9d e3 bf 98 	save  %sp, -104, %sp                           
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
 2012d78:	c2 0e 20 89 	ldub  [ %i0 + 0x89 ], %g1                      
    return RC_OK;                                                     
}                                                                     
                                                                      
int                                                                   
fat_buf_release(fat_fs_info_t *fs_info)                               
{                                                                     
 2012d7c:	ba 10 00 18 	mov  %i0, %i5                                  
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
 2012d80:	80 a0 60 00 	cmp  %g1, 0                                    
 2012d84:	02 80 00 6e 	be  2012f3c <fat_buf_release+0x1c8>            
 2012d88:	b0 10 20 00 	clr  %i0                                       
        return RC_OK;                                                 
                                                                      
    if (fs_info->c.modified)                                          
 2012d8c:	c2 0f 60 88 	ldub  [ %i5 + 0x88 ], %g1                      
 2012d90:	80 a0 60 00 	cmp  %g1, 0                                    
 2012d94:	02 80 00 5d 	be  2012f08 <fat_buf_release+0x194>            
 2012d98:	01 00 00 00 	nop                                            
    {                                                                 
        uint32_t sec_num = fs_info->c.blk_num;                        
 2012d9c:	c2 07 60 84 	ld  [ %i5 + 0x84 ], %g1                        
        bool     sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&   
 2012da0:	c4 17 60 18 	lduh  [ %i5 + 0x18 ], %g2                      
 2012da4:	80 a0 40 02 	cmp  %g1, %g2                                  
 2012da8:	0a 80 00 05 	bcs  2012dbc <fat_buf_release+0x48>            
 2012dac:	b8 10 20 00 	clr  %i4                                       
 2012db0:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
 2012db4:	80 a0 40 02 	cmp  %g1, %g2                                  
 2012db8:	b8 40 20 00 	addx  %g0, 0, %i4                              
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
 2012dbc:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         
        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)                       
 2012dc0:	80 8f 20 ff 	btst  0xff, %i4                                
 2012dc4:	02 80 00 12 	be  2012e0c <fat_buf_release+0x98>             
 2012dc8:	c6 0f 60 0c 	ldub  [ %i5 + 0xc ], %g3                       
 2012dcc:	c8 0f 60 54 	ldub  [ %i5 + 0x54 ], %g4                      
 2012dd0:	80 a1 20 00 	cmp  %g4, 0                                    
 2012dd4:	12 80 00 0e 	bne  2012e0c <fat_buf_release+0x98>            <== NEVER TAKEN
 2012dd8:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
            memcpy(fs_info->sec_buf,                                  
                   fs_info->c.buf->buffer + blk_ofs,                  
 2012ddc:	c8 07 60 8c 	ld  [ %i5 + 0x8c ], %g4                        
        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,                                  
 2012de0:	d0 07 60 90 	ld  [ %i5 + 0x90 ], %o0                        
 2012de4:	d2 01 20 1c 	ld  [ %g4 + 0x1c ], %o1                        
 2012de8:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
 2012dec:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
 2012df0:	86 20 c0 02 	sub  %g3, %g2, %g3                             
 2012df4:	b7 30 40 03 	srl  %g1, %g3, %i3                             
                                                                      
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);
 2012df8:	87 2e c0 03 	sll  %i3, %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 -                                                 
 2012dfc:	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);                                
 2012e00:	85 28 40 02 	sll  %g1, %g2, %g2                             
 2012e04:	40 00 24 a9 	call  201c0a8 <memcpy>                         
 2012e08:	92 02 40 02 	add  %o1, %g2, %o1                             
                   fs_info->c.buf->buffer + blk_ofs,                  
                   fs_info->vol.bps);                                 
                                                                      
        sc = rtems_bdbuf_release_modified(fs_info->c.buf);            
 2012e0c:	7f ff f8 c4 	call  201111c <rtems_bdbuf_release_modified>   
 2012e10:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
        if (sc != RTEMS_SUCCESSFUL)                                   
 2012e14:	80 a2 20 00 	cmp  %o0, 0                                    
 2012e18:	12 80 00 41 	bne  2012f1c <fat_buf_release+0x1a8>           <== NEVER TAKEN
 2012e1c:	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)                       
 2012e20:	02 80 00 45 	be  2012f34 <fat_buf_release+0x1c0>            
 2012e24:	c0 2f 60 88 	clrb  [ %i5 + 0x88 ]                           
 2012e28:	c2 0f 60 54 	ldub  [ %i5 + 0x54 ], %g1                      
 2012e2c:	80 a0 60 00 	cmp  %g1, 0                                    
 2012e30:	22 80 00 2f 	be,a   2012eec <fat_buf_release+0x178>         <== ALWAYS TAKEN
 2012e34:	b8 10 20 01 	mov  1, %i4                                    
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
    }                                                                 
    fs_info->c.state = FAT_CACHE_EMPTY;                               
 2012e38:	10 80 00 40 	b  2012f38 <fat_buf_release+0x1c4>             <== NOT EXECUTED
 2012e3c:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           <== NOT EXECUTED
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
            {                                                         
                rtems_bdbuf_buffer *bd;                               
                                                                      
                sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
 2012e40:	7f ff be 04 	call  2002650 <.umul>                          
 2012e44:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
 2012e48:	f6 07 60 84 	ld  [ %i5 + 0x84 ], %i3                        
                                                                      
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);
 2012e4c:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
 2012e50:	90 02 00 1b 	add  %o0, %i3, %o0                             
 2012e54:	f6 0f 60 0c 	ldub  [ %i5 + 0xc ], %i3                       
 2012e58:	b6 26 c0 01 	sub  %i3, %g1, %i3                             
 2012e5c:	93 32 00 1b 	srl  %o0, %i3, %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);
 2012e60:	b7 2a 40 1b 	sll  %o1, %i3, %i3                             
 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 -                                                 
 2012e64:	b6 22 00 1b 	sub  %o0, %i3, %i3                             
              fat_block_num_to_sector_num (fs_info,                   
                  fat_sector_num_to_block_num (fs_info, sector)))     
            << fs_info->vol.sec_log2);                                
 2012e68:	b7 2e c0 01 	sll  %i3, %g1, %i3                             
                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                                      
 2012e6c:	80 a6 e0 00 	cmp  %i3, 0                                    
 2012e70:	12 80 00 0b 	bne  2012e9c <fat_buf_release+0x128>           
 2012e74:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
                    && fs_info->vol.bps == fs_info->vol.bytes_per_block)
 2012e78:	c4 17 40 00 	lduh  [ %i5 ], %g2                             
 2012e7c:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
 2012e80:	80 a0 80 01 	cmp  %g2, %g1                                  
 2012e84:	12 80 00 06 	bne  2012e9c <fat_buf_release+0x128>           
 2012e88:	01 00 00 00 	nop                                            
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);  
 2012e8c:	7f ff f7 c2 	call  2010d94 <rtems_bdbuf_get>                
 2012e90:	94 07 bf fc 	add  %fp, -4, %o2                              
                }                                                     
                else                                                  
                {                                                     
                    sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 
                }                                                     
                if ( sc != RTEMS_SUCCESSFUL)                          
 2012e94:	10 80 00 05 	b  2012ea8 <fat_buf_release+0x134>             
 2012e98:	80 a2 20 00 	cmp  %o0, 0                                    
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);  
                }                                                     
                else                                                  
                {                                                     
                    sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 
 2012e9c:	7f ff f7 ef 	call  2010e58 <rtems_bdbuf_read>               
 2012ea0:	94 07 bf fc 	add  %fp, -4, %o2                              
                }                                                     
                if ( sc != RTEMS_SUCCESSFUL)                          
 2012ea4:	80 a2 20 00 	cmp  %o0, 0                                    
 2012ea8:	22 80 00 03 	be,a   2012eb4 <fat_buf_release+0x140>         <== ALWAYS TAKEN
 2012eac:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2012eb0:	30 80 00 0b 	b,a   2012edc <fat_buf_release+0x168>          <== NOT EXECUTED
                    rtems_set_errno_and_return_minus_one(ENOMEM);     
                memcpy(bd->buffer + blk_ofs, fs_info->sec_buf, fs_info->vol.bps);
 2012eb4:	d2 07 60 90 	ld  [ %i5 + 0x90 ], %o1                        
 2012eb8:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 2012ebc:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
 2012ec0:	40 00 24 7a 	call  201c0a8 <memcpy>                         
 2012ec4:	90 02 00 1b 	add  %o0, %i3, %o0                             
                sc = rtems_bdbuf_release_modified(bd);                
 2012ec8:	7f ff f8 95 	call  201111c <rtems_bdbuf_release_modified>   
 2012ecc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                if ( sc != RTEMS_SUCCESSFUL)                          
 2012ed0:	80 a2 20 00 	cmp  %o0, 0                                    
 2012ed4:	22 80 00 06 	be,a   2012eec <fat_buf_release+0x178>         <== ALWAYS TAKEN
 2012ed8:	b8 07 20 01 	inc  %i4                                       
                    rtems_set_errno_and_return_minus_one(ENOMEM);     
 2012edc:	40 00 21 b4 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2012ee0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012ee4:	10 80 00 11 	b  2012f28 <fat_buf_release+0x1b4>             <== NOT EXECUTED
 2012ee8:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
                                                                      
        if (sec_of_fat && !fs_info->vol.mirror)                       
        {                                                             
            uint8_t i;                                                
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
 2012eec:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       
 2012ef0:	90 0f 20 ff 	and  %i4, 0xff, %o0                            
 2012ef4:	80 a2 00 01 	cmp  %o0, %g1                                  
 2012ef8:	0a bf ff d2 	bcs  2012e40 <fat_buf_release+0xcc>            
 2012efc:	01 00 00 00 	nop                                            
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
        if (sc != RTEMS_SUCCESSFUL)                                   
            rtems_set_errno_and_return_minus_one(EIO);                
    }                                                                 
    fs_info->c.state = FAT_CACHE_EMPTY;                               
 2012f00:	10 80 00 0e 	b  2012f38 <fat_buf_release+0x1c4>             
 2012f04:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
 2012f08:	7f ff f8 50 	call  2011048 <rtems_bdbuf_release>            
 2012f0c:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
        if (sc != RTEMS_SUCCESSFUL)                                   
 2012f10:	80 a2 20 00 	cmp  %o0, 0                                    
 2012f14:	22 80 00 09 	be,a   2012f38 <fat_buf_release+0x1c4>         <== ALWAYS TAKEN
 2012f18:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
            rtems_set_errno_and_return_minus_one(EIO);                
 2012f1c:	40 00 21 a4 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2012f20:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012f24:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
 2012f28:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2012f2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012f30:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
    }                                                                 
    fs_info->c.state = FAT_CACHE_EMPTY;                               
 2012f34:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
    return RC_OK;                                                     
 2012f38:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 2012f3c:	81 c7 e0 08 	ret                                            
 2012f40:	81 e8 00 00 	restore                                        
                                                                      

02012d18 <fat_cluster_num_to_block_num>: 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)) )
 2012d18:	80 a2 60 00 	cmp  %o1, 0                                    
 2012d1c:	32 80 00 0c 	bne,a   2012d4c <fat_cluster_num_to_block_num+0x34>
 2012d20:	c2 0a 20 0c 	ldub  [ %o0 + 0xc ], %g1                       
 2012d24:	c2 0a 20 0e 	ldub  [ %o0 + 0xe ], %g1                       
 2012d28:	80 88 60 03 	btst  3, %g1                                   
 2012d2c:	22 80 00 08 	be,a   2012d4c <fat_cluster_num_to_block_num+0x34><== NEVER TAKEN
 2012d30:	c2 0a 20 0c 	ldub  [ %o0 + 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);
 2012d34:	c4 0a 20 0c 	ldub  [ %o0 + 0xc ], %g2                       
 2012d38:	c2 0a 20 02 	ldub  [ %o0 + 2 ], %g1                         
 2012d3c:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
 2012d40:	82 20 80 01 	sub  %g2, %g1, %g1                             
 2012d44:	81 c3 e0 08 	retl                                           
 2012d48:	91 32 00 01 	srl  %o0, %g1, %o0                             
        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);
 2012d4c:	c4 0a 20 08 	ldub  [ %o0 + 8 ], %g2                         
                                                                      
    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;                                         
 2012d50:	92 02 7f fe 	add  %o1, -2, %o1                              
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
 2012d54:	84 20 80 01 	sub  %g2, %g1, %g2                             
 2012d58:	93 2a 40 02 	sll  %o1, %g2, %o1                             
 2012d5c:	c4 0a 20 02 	ldub  [ %o0 + 2 ], %g2                         
 2012d60:	d0 02 20 34 	ld  [ %o0 + 0x34 ], %o0                        
 2012d64:	82 20 40 02 	sub  %g1, %g2, %g1                             
 2012d68:	91 32 00 01 	srl  %o0, %g1, %o0                             
        blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
    }                                                                 
                                                                      
    return blk;                                                       
}                                                                     
 2012d6c:	81 c3 e0 08 	retl                                           
 2012d70:	90 02 00 09 	add  %o0, %o1, %o0                             
                                                                      

02012074 <fat_cluster_num_to_sector_num>: 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)) )
 2012074:	80 a2 60 00 	cmp  %o1, 0                                    
 2012078:	32 80 00 08 	bne,a   2012098 <fat_cluster_num_to_sector_num+0x24>
 201207c:	c2 0a 20 05 	ldub  [ %o0 + 5 ], %g1                         
 2012080:	c2 0a 20 0e 	ldub  [ %o0 + 0xe ], %g1                       
 2012084:	80 88 60 03 	btst  3, %g1                                   
 2012088:	22 80 00 04 	be,a   2012098 <fat_cluster_num_to_sector_num+0x24><== NEVER TAKEN
 201208c:	c2 0a 20 05 	ldub  [ %o0 + 5 ], %g1                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
 2012090:	81 c3 e0 08 	retl                                           
 2012094:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
 2012098:	92 02 7f fe 	add  %o1, -2, %o1                              
 201209c:	93 2a 40 01 	sll  %o1, %g1, %o1                             
 20120a0:	c2 02 20 34 	ld  [ %o0 + 0x34 ], %g1                        
            fs_info->vol.data_fsec);                                  
}                                                                     
 20120a4:	81 c3 e0 08 	retl                                           
 20120a8:	90 02 40 01 	add  %o1, %g1, %o0                             
                                                                      

02013118 <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) {
 2013118:	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));
 201311c:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
 2013120:	82 20 40 1a 	sub  %g1, %i2, %g1                             
 2013124:	80 a6 c0 01 	cmp  %i3, %g1                                  
 2013128:	38 80 00 02 	bgu,a   2013130 <fat_cluster_set+0x18>         <== NEVER TAKEN
 201312c:	b6 10 00 01 	mov  %g1, %i3                                  <== NOT EXECUTED
  uint32_t            cur_blk          = fat_cluster_num_to_block_num(fs_info, start_cln);
 2013130:	90 10 00 18 	mov  %i0, %o0                                  
 2013134:	7f ff fe f9 	call  2012d18 <fat_cluster_num_to_block_num>   
 2013138:	92 10 00 19 	mov  %i1, %o1                                  
  uint32_t            blocks_in_offset = offset >> fs_info->vol.bytes_per_block_log2;
 201313c:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
  uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
  ssize_t             bytes_written    = 0;                           
 2013140:	a0 10 20 00 	clr  %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;
 2013144:	a3 36 80 01 	srl  %i2, %g1, %l1                             
  uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
 2013148:	83 2c 40 01 	sll  %l1, %g1, %g1                             
 201314c:	a4 10 20 01 	mov  1, %l2                                    
 2013150:	b4 26 80 01 	sub  %i2, %g1, %i2                             
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
 2013154:	a2 02 00 11 	add  %o0, %l1, %l1                             
                                                                      
  while (   (RC_OK == rc)                                             
 2013158:	10 80 00 2a 	b  2013200 <fat_cluster_set+0xe8>              
 201315c:	82 10 20 00 	clr  %g1                                       
         && (0 < bytes_to_write))                                     
  {                                                                   
    uint32_t c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
 2013160:	82 20 80 1a 	sub  %g2, %i2, %g1                             
 2013164:	80 a0 40 1b 	cmp  %g1, %i3                                  
 2013168:	08 80 00 03 	bleu  2013174 <fat_cluster_set+0x5c>           <== ALWAYS TAKEN
 201316c:	ba 10 00 01 	mov  %g1, %i5                                  
 2013170:	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));
 2013174:	80 a7 40 01 	cmp  %i5, %g1                                  
 2013178:	08 80 00 03 	bleu  2013184 <fat_cluster_set+0x6c>           <== ALWAYS TAKEN
 201317c:	b2 10 00 1d 	mov  %i5, %i1                                  
 2013180:	b2 10 00 01 	mov  %g1, %i1                                  <== NOT EXECUTED
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
 2013184:	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)                                           
 2013188:	80 a6 60 00 	cmp  %i1, 0                                    
 201318c:	02 80 00 27 	be  2013228 <fat_cluster_set+0x110>            <== NEVER TAKEN
 2013190:	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);
 2013194:	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);
 2013198:	90 10 00 18 	mov  %i0, %o0                                  
 201319c:	93 2c 40 09 	sll  %l1, %o1, %o1                             
    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)           
 20131a0:	80 a6 40 02 	cmp  %i1, %g2                                  
 20131a4:	02 80 00 03 	be  20131b0 <fat_cluster_set+0x98>             
 20131a8:	94 10 20 02 	mov  2, %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);
 20131ac:	94 10 20 01 	mov  1, %o2                                    
 20131b0:	7f ff ff 65 	call  2012f44 <fat_buf_access>                 
 20131b4:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      
        if (RC_OK == rc)                                              
 20131b8:	80 a2 20 00 	cmp  %o0, 0                                    
 20131bc:	12 80 00 0a 	bne  20131e4 <fat_cluster_set+0xcc>            <== NEVER TAKEN
 20131c0:	80 a7 40 08 	cmp  %i5, %o0                                  
        {                                                             
            memset(blk_buf + offset, pattern, bytes_to_write);        
 20131c4:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 20131c8:	92 10 00 1c 	mov  %i4, %o1                                  
 20131cc:	90 02 00 1a 	add  %o0, %i2, %o0                             
 20131d0:	40 00 23 f3 	call  201c19c <memset>                         
 20131d4:	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;                                       
 20131d8:	10 80 00 14 	b  2013228 <fat_cluster_set+0x110>             
 20131dc:	e4 2e 20 88 	stb  %l2, [ %i0 + 0x88 ]                       
        fs_info,                                                      
        cur_blk,                                                      
        ofs_blk,                                                      
        c,                                                            
        pattern);                                                     
    if (c != ret)                                                     
 20131e0:	80 a7 40 08 	cmp  %i5, %o0                                  
 20131e4:	12 80 00 06 	bne  20131fc <fat_cluster_set+0xe4>            <== NEVER TAKEN
 20131e8:	82 10 3f ff 	mov  -1, %g1                                   
      rc = -1;                                                        
    else                                                              
    {                                                                 
        bytes_to_write -= ret;                                        
 20131ec:	b6 26 c0 1d 	sub  %i3, %i5, %i3                             
        bytes_written  += ret;                                        
 20131f0:	a0 04 00 1d 	add  %l0, %i5, %l0                             
        ++cur_blk;                                                    
 20131f4:	a2 04 60 01 	inc  %l1                                       
 20131f8:	82 10 20 00 	clr  %g1                                       
 20131fc:	b4 10 20 00 	clr  %i2                                       
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
                                                                      
  while (   (RC_OK == rc)                                             
 2013200:	80 a6 e0 00 	cmp  %i3, 0                                    
 2013204:	02 80 00 04 	be  2013214 <fat_cluster_set+0xfc>             
 2013208:	80 a0 60 00 	cmp  %g1, 0                                    
 201320c:	22 bf ff d5 	be,a   2013160 <fat_cluster_set+0x48>          <== ALWAYS TAKEN
 2013210:	c4 16 20 0a 	lduh  [ %i0 + 0xa ], %g2                       
        bytes_written  += ret;                                        
        ++cur_blk;                                                    
    }                                                                 
    ofs_blk = 0;                                                      
  }                                                                   
  if (RC_OK != rc)                                                    
 2013214:	80 a0 60 00 	cmp  %g1, 0                                    
 2013218:	12 80 00 06 	bne  2013230 <fat_cluster_set+0x118>           <== NEVER TAKEN
 201321c:	b0 10 3f ff 	mov  -1, %i0                                   
 2013220:	81 c7 e0 08 	ret                                            
 2013224:	91 e8 00 10 	restore  %g0, %l0, %o0                         
        }                                                             
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return bytes_to_write;                                        
 2013228:	10 bf ff ee 	b  20131e0 <fat_cluster_set+0xc8>              
 201322c:	90 10 00 19 	mov  %i1, %o0                                  
  }                                                                   
  if (RC_OK != rc)                                                    
    return rc;                                                        
  else                                                                
    return bytes_written;                                             
}                                                                     
 2013230:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013234:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02013238 <fat_cluster_write>: const uint32_t start_cln, const uint32_t offset, const uint32_t count, const void *buff, const bool overwrite_cluster) {
 2013238:	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));
 201323c:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
 2013240:	82 20 40 1a 	sub  %g1, %i2, %g1                             
 2013244:	80 a6 c0 01 	cmp  %i3, %g1                                  
 2013248:	38 80 00 02 	bgu,a   2013250 <fat_cluster_write+0x18>       <== NEVER TAKEN
 201324c:	b6 10 00 01 	mov  %g1, %i3                                  <== NOT EXECUTED
    uint32_t            cur_blk          = fat_cluster_num_to_block_num(fs_info, start_cln);
 2013250:	90 10 00 18 	mov  %i0, %o0                                  
 2013254:	7f ff fe b1 	call  2012d18 <fat_cluster_num_to_block_num>   
 2013258:	92 10 00 19 	mov  %i1, %o1                                  
    uint32_t            blocks_in_offset = (offset >> fs_info->vol.bytes_per_block_log2);
 201325c:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
    uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
    ssize_t             bytes_written    = 0;                         
 2013260:	a2 10 20 00 	clr  %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);
 2013264:	a5 36 80 01 	srl  %i2, %g1, %l2                             
    uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
 2013268:	83 2c 80 01 	sll  %l2, %g1, %g1                             
 201326c:	a6 10 20 01 	mov  1, %l3                                    
 2013270:	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;                                      
 2013274:	a4 02 00 12 	add  %o0, %l2, %l2                             
                                                                      
    while (   (RC_OK == rc)                                           
 2013278:	10 80 00 2d 	b  201332c <fat_cluster_write+0xf4>            
 201327c:	82 10 20 00 	clr  %g1                                       
           && (0 < bytes_to_write))                                   
    {                                                                 
      c = MIN(bytes_to_write, (fs_info->vol.bytes_per_block - ofs_blk));
 2013280:	82 20 80 1a 	sub  %g2, %i2, %g1                             
 2013284:	80 a0 40 1b 	cmp  %g1, %i3                                  
 2013288:	08 80 00 03 	bleu  2013294 <fat_cluster_write+0x5c>         
 201328c:	b2 10 00 01 	mov  %g1, %i1                                  
 2013290:	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));
 2013294:	80 a6 40 01 	cmp  %i1, %g1                                  
 2013298:	08 80 00 03 	bleu  20132a4 <fat_cluster_write+0x6c>         <== ALWAYS TAKEN
 201329c:	a0 10 00 19 	mov  %i1, %l0                                  
 20132a0:	a0 10 00 01 	mov  %g1, %l0                                  <== NOT EXECUTED
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
 20132a4:	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)                                           
 20132a8:	80 a4 20 00 	cmp  %l0, 0                                    
 20132ac:	02 80 00 2a 	be  2013354 <fat_cluster_write+0x11c>          <== NEVER TAKEN
 20132b0:	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);
 20132b4:	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);
 20132b8:	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                                        
 20132bc:	80 a7 60 00 	cmp  %i5, 0                                    
 20132c0:	12 80 00 05 	bne  20132d4 <fat_cluster_write+0x9c>          
 20132c4:	93 2c 80 09 	sll  %l2, %o1, %o1                             
            || (bytes_to_write == fs_info->vol.bytes_per_block))      
 20132c8:	80 a4 00 02 	cmp  %l0, %g2                                  
 20132cc:	12 80 00 04 	bne  20132dc <fat_cluster_write+0xa4>          
 20132d0:	94 10 20 01 	mov  1, %o2                                    
        {                                                             
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &blk_buf);
 20132d4:	10 80 00 02 	b  20132dc <fat_cluster_write+0xa4>            
 20132d8:	94 10 20 02 	mov  2, %o2                                    
        }                                                             
        else                                                          
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &blk_buf);
 20132dc:	7f ff ff 1a 	call  2012f44 <fat_buf_access>                 
 20132e0:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      
        if (RC_OK == rc)                                              
 20132e4:	80 a2 20 00 	cmp  %o0, 0                                    
 20132e8:	12 80 00 0a 	bne  2013310 <fat_cluster_write+0xd8>          <== NEVER TAKEN
 20132ec:	80 a6 40 08 	cmp  %i1, %o0                                  
        {                                                             
            memcpy(blk_buf + offset, buf, bytes_to_write);            
 20132f0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 20132f4:	92 07 00 11 	add  %i4, %l1, %o1                             
 20132f8:	90 02 00 1a 	add  %o0, %i2, %o0                             
 20132fc:	40 00 23 6b 	call  201c0a8 <memcpy>                         
 2013300:	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;                                       
 2013304:	10 80 00 14 	b  2013354 <fat_cluster_write+0x11c>           
 2013308:	e6 2e 20 88 	stb  %l3, [ %i0 + 0x88 ]                       
          cur_blk,                                                    
          ofs_blk,                                                    
          c,                                                          
          &buffer[bytes_written],                                     
          overwrite_cluster);                                         
      if (c != ret)                                                   
 201330c:	80 a6 40 08 	cmp  %i1, %o0                                  
 2013310:	12 80 00 06 	bne  2013328 <fat_cluster_write+0xf0>          <== NEVER TAKEN
 2013314:	82 10 3f ff 	mov  -1, %g1                                   
        rc = -1;                                                      
      else                                                            
      {                                                               
          bytes_to_write -= ret;                                      
 2013318:	b6 26 c0 19 	sub  %i3, %i1, %i3                             
          bytes_written  += ret;                                      
 201331c:	a2 04 40 19 	add  %l1, %i1, %l1                             
          ++cur_blk;                                                  
 2013320:	a4 04 a0 01 	inc  %l2                                       
 2013324:	82 10 20 00 	clr  %g1                                       
 2013328:	b4 10 20 00 	clr  %i2                                       
    ssize_t             ret;                                          
    uint32_t            c;                                            
                                                                      
    cur_blk += blocks_in_offset;                                      
                                                                      
    while (   (RC_OK == rc)                                           
 201332c:	80 a6 e0 00 	cmp  %i3, 0                                    
 2013330:	02 80 00 04 	be  2013340 <fat_cluster_write+0x108>          
 2013334:	80 a0 60 00 	cmp  %g1, 0                                    
 2013338:	22 bf ff d2 	be,a   2013280 <fat_cluster_write+0x48>        <== ALWAYS TAKEN
 201333c:	c4 16 20 0a 	lduh  [ %i0 + 0xa ], %g2                       
          bytes_written  += ret;                                      
          ++cur_blk;                                                  
      }                                                               
      ofs_blk = 0;                                                    
    }                                                                 
    if (RC_OK != rc)                                                  
 2013340:	80 a0 60 00 	cmp  %g1, 0                                    
 2013344:	12 80 00 06 	bne  201335c <fat_cluster_write+0x124>         <== NEVER TAKEN
 2013348:	b0 10 3f ff 	mov  -1, %i0                                   
 201334c:	81 c7 e0 08 	ret                                            
 2013350:	91 e8 00 11 	restore  %g0, %l1, %o0                         
        }                                                             
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return bytes_to_write;                                        
 2013354:	10 bf ff ee 	b  201330c <fat_cluster_write+0xd4>            
 2013358:	90 10 00 10 	mov  %l0, %o0                                  
    }                                                                 
    if (RC_OK != rc)                                                  
      return rc;                                                      
    else                                                              
      return bytes_written;                                           
}                                                                     
 201335c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013360:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020125e0 <fat_file_close>: int fat_file_close( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
 20125e0:	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)                                        
 20125e4:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 20125e8:	80 a0 60 01 	cmp  %g1, 1                                    
 20125ec:	08 80 00 05 	bleu  2012600 <fat_file_close+0x20>            
 20125f0:	82 00 7f ff 	add  %g1, -1, %g1                              
    {                                                                 
        fat_fd->links_num--;                                          
        return rc;                                                    
 20125f4:	90 10 20 00 	clr  %o0                                       
 20125f8:	10 80 00 25 	b  201268c <fat_file_close+0xac>               
 20125fc:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
    }                                                                 
                                                                      
    key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);         
                                                                      
    if (fat_fd->flags & FAT_FILE_REMOVED)                             
 2012600:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
 2012604:	80 88 60 01 	btst  1, %g1                                   
 2012608:	02 80 00 14 	be  2012658 <fat_file_close+0x78>              
 201260c:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
        rc = fat_file_truncate(fs_info, fat_fd, 0);                   
 2012610:	92 10 00 19 	mov  %i1, %o1                                  
 2012614:	7f ff ff ae 	call  20124cc <fat_file_truncate>              
 2012618:	94 10 20 00 	clr  %o2                                       
        if ( rc != RC_OK )                                            
 201261c:	80 a2 20 00 	cmp  %o0, 0                                    
 2012620:	12 80 00 1b 	bne  201268c <fat_file_close+0xac>             <== NEVER TAKEN
 2012624:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
 2012628:	40 00 0e ac 	call  20160d8 <_Chain_Extract>                 
 201262c:	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) )                
 2012630:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         
 2012634:	40 00 06 01 	call  2013e38 <fat_ino_is_unique>              
 2012638:	90 10 00 18 	mov  %i0, %o0                                  
 201263c:	80 8a 20 ff 	btst  0xff, %o0                                
 2012640:	02 80 00 0f 	be  201267c <fat_file_close+0x9c>              <== ALWAYS TAKEN
 2012644:	01 00 00 00 	nop                                            
            fat_free_unique_ino(fs_info, fat_fd->ino);                
 2012648:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         <== NOT EXECUTED
 201264c:	40 00 05 f0 	call  2013e0c <fat_free_unique_ino>            <== NOT EXECUTED
 2012650:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2012654:	30 80 00 0a 	b,a   201267c <fat_file_close+0x9c>            <== NOT EXECUTED
                                                                      
        free(fat_fd);                                                 
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_ino_is_unique(fs_info, fat_fd->ino))                  
 2012658:	40 00 05 f8 	call  2013e38 <fat_ino_is_unique>              
 201265c:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         
 2012660:	80 8a 20 ff 	btst  0xff, %o0                                
 2012664:	02 80 00 04 	be  2012674 <fat_file_close+0x94>              <== ALWAYS TAKEN
 2012668:	01 00 00 00 	nop                                            
        {                                                             
            fat_fd->links_num = 0;                                    
 201266c:	10 80 00 06 	b  2012684 <fat_file_close+0xa4>               <== NOT EXECUTED
 2012670:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
 2012674:	40 00 0e 99 	call  20160d8 <_Chain_Extract>                 
 2012678:	90 10 00 19 	mov  %i1, %o0                                  
        }                                                             
        else                                                          
        {                                                             
            _hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);   
            free(fat_fd);                                             
 201267c:	7f ff cb 36 	call  2005354 <free>                           
 2012680:	90 10 00 19 	mov  %i1, %o0                                  
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
 2012684:	40 00 01 bc 	call  2012d74 <fat_buf_release>                
 2012688:	81 e8 00 00 	restore                                        
                                                                      
    return rc;                                                        
}                                                                     
 201268c:	81 c7 e0 08 	ret                                            
 2012690:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

02012764 <fat_file_extend>: fat_file_fd_t *fat_fd, bool zero_fill, uint32_t new_length, uint32_t *a_length ) {
 2012764:	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;                                           
 2012768:	f6 27 00 00 	st  %i3, [ %i4 ]                               
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
 201276c:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t                              new_length,                 
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       chain = 0;                                         
 2012770:	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;                                       
 2012774:	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)                          
 2012778:	80 a6 c0 01 	cmp  %i3, %g1                                  
 201277c:	18 80 00 04 	bgu  201278c <fat_file_extend+0x28>            
 2012780:	ba 10 00 18 	mov  %i0, %i5                                  
        return RC_OK;                                                 
 2012784:	81 c7 e0 08 	ret                                            
 2012788:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
 201278c:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
 2012790:	80 a0 a0 01 	cmp  %g2, 1                                    
 2012794:	32 80 00 0b 	bne,a   20127c0 <fat_file_extend+0x5c>         
 2012798:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
 201279c:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
 20127a0:	80 a0 a0 00 	cmp  %g2, 0                                    
 20127a4:	32 80 00 07 	bne,a   20127c0 <fat_file_extend+0x5c>         <== NEVER TAKEN
 20127a8:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
 20127ac:	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)) &&                               
 20127b0:	80 88 a0 03 	btst  3, %g2                                   
 20127b4:	22 80 00 03 	be,a   20127c0 <fat_file_extend+0x5c>          <== NEVER TAKEN
 20127b8:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         <== NOT EXECUTED
 20127bc:	30 80 00 34 	b,a   201288c <fat_file_extend+0x128>          
        (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))) &
 20127c0:	84 04 3f ff 	add  %l0, -1, %g2                              
 20127c4:	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 -                                
 20127c8:	a0 24 00 12 	sub  %l0, %l2, %l0                             
 20127cc:	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;                   
 20127d0:	84 26 c0 01 	sub  %i3, %g1, %g2                             
                                                                      
    if (bytes2add > bytes_remain)                                     
 20127d4:	80 a0 80 10 	cmp  %g2, %l0                                  
 20127d8:	08 80 00 03 	bleu  20127e4 <fat_file_extend+0x80>           
 20127dc:	a2 10 20 00 	clr  %l1                                       
        bytes2add -= bytes_remain;                                    
 20127e0:	a2 20 80 10 	sub  %g2, %l0, %l1                             
    else                                                              
        bytes2add = 0;                                                
                                                                      
    if (zero_fill && bytes_remain > 0) {                              
 20127e4:	80 a4 20 00 	cmp  %l0, 0                                    
 20127e8:	02 80 00 17 	be  2012844 <fat_file_extend+0xe0>             
 20127ec:	80 a4 60 00 	cmp  %l1, 0                                    
 20127f0:	80 a6 a0 00 	cmp  %i2, 0                                    
 20127f4:	02 80 00 14 	be  2012844 <fat_file_extend+0xe0>             
 20127f8:	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;           
 20127fc:	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);     
 2012800:	90 10 00 1d 	mov  %i5, %o0                                  
 2012804:	92 10 00 19 	mov  %i1, %o1                                  
 2012808:	95 30 40 0a 	srl  %g1, %o2, %o2                             
 201280c:	7f ff fe 39 	call  20120f0 <fat_file_lseek>                 
 2012810:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
 2012814:	b0 92 60 00 	orcc  %o1, 0, %i0                              
 2012818:	12 80 00 21 	bne  201289c <fat_file_extend+0x138>           <== NEVER TAKEN
 201281c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
            return rc;                                                
                                                                      
        bytes_written = fat_cluster_set (fs_info, cur_cln, ofs, bytes_remain, 0);
 2012820:	90 10 00 1d 	mov  %i5, %o0                                  
 2012824:	94 10 00 12 	mov  %l2, %o2                                  
 2012828:	96 10 00 10 	mov  %l0, %o3                                  
 201282c:	98 10 20 00 	clr  %o4                                       
 2012830:	40 00 02 3a 	call  2013118 <fat_cluster_set>                
 2012834:	b0 10 3f ff 	mov  -1, %i0                                   
        if (bytes_remain != bytes_written)                            
 2012838:	80 a4 00 08 	cmp  %l0, %o0                                  
 201283c:	12 80 00 18 	bne  201289c <fat_file_extend+0x138>           <== NEVER TAKEN
 2012840:	80 a4 60 00 	cmp  %l1, 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)                                               
 2012844:	02 bf ff d0 	be  2012784 <fat_file_extend+0x20>             
 2012848:	a4 04 7f ff 	add  %l1, -1, %l2                              
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
 201284c:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
 2012850:	90 10 00 1d 	mov  %i5, %o0                                  
     * file ) - return                                                
     */                                                               
    if (bytes2add == 0)                                               
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
 2012854:	a5 34 80 01 	srl  %l2, %g1, %l2                             
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
 2012858:	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;         
 201285c:	a4 04 a0 01 	inc  %l2                                       
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
 2012860:	96 07 bf fc 	add  %fp, -4, %o3                              
 2012864:	94 10 00 12 	mov  %l2, %o2                                  
 2012868:	98 07 bf f8 	add  %fp, -8, %o4                              
 201286c:	40 00 1c 82 	call  2019a74 <fat_scan_fat_for_free_clusters> 
 2012870:	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)                                                  
 2012874:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2012878:	12 80 00 09 	bne  201289c <fat_file_extend+0x138>           <== NEVER TAKEN
 201287c:	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))                      
 2012880:	80 94 00 01 	orcc  %l0, %g1, %g0                            
 2012884:	12 80 00 08 	bne  20128a4 <fat_file_extend+0x140>           <== ALWAYS TAKEN
 2012888:	80 a4 80 01 	cmp  %l2, %g1                                  
        rtems_set_errno_and_return_minus_one(ENOSPC);                 
 201288c:	40 00 23 48 	call  201b5ac <__errno>                        
 2012890:	b0 10 3f ff 	mov  -1, %i0                                   
 2012894:	82 10 20 1c 	mov  0x1c, %g1                                 
 2012898:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 201289c:	81 c7 e0 08 	ret                                            
 20128a0:	81 e8 00 00 	restore                                        
                                                                      
    /*  check wether we satisfied request for 'cls2add' clusters */   
    if (cls2add != cls_added)                                         
 20128a4:	02 80 00 09 	be  20128c8 <fat_file_extend+0x164>            <== ALWAYS TAKEN
 20128a8:	82 24 80 01 	sub  %l2, %g1, %g1                             
    {                                                                 
        new_length -= bytes2add & (fs_info->vol.bpc - 1);             
 20128ac:	c4 17 60 06 	lduh  [ %i5 + 6 ], %g2                         <== NOT EXECUTED
 20128b0:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
 20128b4:	a2 0c 40 02 	and  %l1, %g2, %l1                             <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
 20128b8:	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);             
 20128bc:	b6 26 c0 11 	sub  %i3, %l1, %i3                             <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
 20128c0:	83 28 40 02 	sll  %g1, %g2, %g1                             <== NOT EXECUTED
 20128c4:	b6 26 c0 01 	sub  %i3, %g1, %i3                             <== NOT EXECUTED
    }                                                                 
                                                                      
    /* add new chain to the end of existed */                         
    if ( fat_fd->fat_file_size == 0 )                                 
 20128c8:	d6 06 60 18 	ld  [ %i1 + 0x18 ], %o3                        
 20128cc:	80 a2 e0 00 	cmp  %o3, 0                                    
 20128d0:	32 80 00 07 	bne,a   20128ec <fat_file_extend+0x188>        
 20128d4:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
    {                                                                 
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
 20128d8:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
        fat_fd->map.file_cln = 0;                                     
 20128dc:	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;                   
 20128e0:	c2 26 60 1c 	st  %g1, [ %i1 + 0x1c ]                        
 20128e4:	10 80 00 1d 	b  2012958 <fat_file_extend+0x1f4>             
 20128e8:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
        fat_fd->map.file_cln = 0;                                     
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)              
 20128ec:	80 a0 7f ff 	cmp  %g1, -1                                   
 20128f0:	22 80 00 04 	be,a   2012900 <fat_file_extend+0x19c>         <== NEVER TAKEN
 20128f4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        {                                                             
            old_last_cl = fat_fd->map.last_cln;                       
 20128f8:	10 80 00 0c 	b  2012928 <fat_file_extend+0x1c4>             
 20128fc:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
        }                                                             
        else                                                          
        {                                                             
            rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,           
 2012900:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2012904:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 2012908:	96 02 ff ff 	add  %o3, -1, %o3                              <== NOT EXECUTED
 201290c:	7f ff ff 62 	call  2012694 <fat_file_ioctl>                 <== NOT EXECUTED
 2012910:	98 07 bf f4 	add  %fp, -12, %o4                             <== NOT EXECUTED
                                (fat_fd->fat_file_size - 1), &old_last_cl);
            if ( rc != RC_OK )                                        
 2012914:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
 2012918:	02 80 00 05 	be  201292c <fat_file_extend+0x1c8>            <== NOT EXECUTED
 201291c:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         <== 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);          
 2012920:	10 80 00 1f 	b  201299c <fat_file_extend+0x238>             <== NOT EXECUTED
 2012924:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                fat_free_fat_clusters_chain(fs_info, chain);          
                return rc;                                            
            }                                                         
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);        
 2012928:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
 201292c:	d4 07 bf f0 	ld  [ %fp + -16 ], %o2                         
 2012930:	40 00 1b 81 	call  2019734 <fat_set_fat_cluster>            
 2012934:	90 10 00 1d 	mov  %i5, %o0                                  
 2012938:	b4 10 00 08 	mov  %o0, %i2                                  
        if ( rc != RC_OK )                                            
 201293c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2012940:	02 80 00 04 	be  2012950 <fat_file_extend+0x1ec>            <== ALWAYS TAKEN
 2012944:	90 10 00 1d 	mov  %i5, %o0                                  
        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);          
 2012948:	10 80 00 16 	b  20129a0 <fat_file_extend+0x23c>             <== NOT EXECUTED
 201294c:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
        if ( rc != RC_OK )                                            
        {                                                             
            fat_free_fat_clusters_chain(fs_info, chain);              
            return rc;                                                
        }                                                             
        fat_buf_release(fs_info);                                     
 2012950:	40 00 01 09 	call  2012d74 <fat_buf_release>                
 2012954:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    /* update number of the last cluster of the file if it changed */ 
    if (cls_added != 0)                                               
 2012958:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 201295c:	80 a0 60 00 	cmp  %g1, 0                                    
 2012960:	22 80 00 14 	be,a   20129b0 <fat_file_extend+0x24c>         <== NEVER TAKEN
 2012964:	f6 27 00 00 	st  %i3, [ %i4 ]                               <== NOT EXECUTED
    {                                                                 
        fat_fd->map.last_cln = last_cl;                               
 2012968:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 201296c:	c2 26 60 3c 	st  %g1, [ %i1 + 0x3c ]                        
        if (fat_fd->fat_file_type == FAT_DIRECTORY)                   
 2012970:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 2012974:	80 a0 60 00 	cmp  %g1, 0                                    
 2012978:	32 80 00 0e 	bne,a   20129b0 <fat_file_extend+0x24c>        
 201297c:	f6 27 00 00 	st  %i3, [ %i4 ]                               
        {                                                             
            rc = fat_init_clusters_chain(fs_info, chain);             
 2012980:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
 2012984:	40 00 04 d4 	call  2013cd4 <fat_init_clusters_chain>        
 2012988:	90 10 00 1d 	mov  %i5, %o0                                  
            if ( rc != RC_OK )                                        
 201298c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 2012990:	22 80 00 08 	be,a   20129b0 <fat_file_extend+0x24c>         <== ALWAYS TAKEN
 2012994:	f6 27 00 00 	st  %i3, [ %i4 ]                               
            {                                                         
                fat_free_fat_clusters_chain(fs_info, chain);          
 2012998:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201299c:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
 20129a0:	40 00 1c 06 	call  20199b8 <fat_free_fat_clusters_chain>    <== NOT EXECUTED
 20129a4:	b0 10 00 1a 	mov  %i2, %i0                                  <== NOT EXECUTED
 20129a8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20129ac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
            }                                                         
        }                                                             
    }                                                                 
                                                                      
    *a_length = new_length;                                           
    fat_fd->fat_file_size = new_length;                               
 20129b0:	f6 26 60 18 	st  %i3, [ %i1 + 0x18 ]                        
                                                                      
    return RC_OK;                                                     
}                                                                     
 20129b4:	81 c7 e0 08 	ret                                            
 20129b8:	81 e8 00 00 	restore                                        
                                                                      

02012694 <fat_file_ioctl>: fat_file_ioctl( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, int cmd, ...) {
 2012694:	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);                                                
 2012698:	82 07 a0 50 	add  %fp, 0x50, %g1                            
 201269c:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
 20126a0:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
 20126a4:	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;                                       
 20126a8:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
                                                                      
    switch (cmd)                                                      
 20126ac:	80 a6 a0 01 	cmp  %i2, 1                                    
 20126b0:	12 80 00 26 	bne  2012748 <fat_file_ioctl+0xb4>             <== NEVER TAKEN
 20126b4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    {                                                                 
        case F_CLU_NUM:                                               
            pos = va_arg(ap, uint32_t);                               
            ret = va_arg(ap, uint32_t *);                             
 20126b8:	82 07 a0 58 	add  %fp, 0x58, %g1                            
 20126bc:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size ) {                     
 20126c0:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
 20126c4:	80 a6 c0 01 	cmp  %i3, %g1                                  
 20126c8:	0a 80 00 06 	bcs  20126e0 <fat_file_ioctl+0x4c>             <== ALWAYS TAKEN
 20126cc:	ba 10 00 1c 	mov  %i4, %i5                                  
                va_end(ap);                                           
                rtems_set_errno_and_return_minus_one( EIO );          
 20126d0:	40 00 23 b7 	call  201b5ac <__errno>                        <== NOT EXECUTED
 20126d4:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20126d8:	10 80 00 1f 	b  2012754 <fat_file_ioctl+0xc0>               <== NOT EXECUTED
 20126dc:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
            }                                                         
                                                                      
            if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                       
 20126e0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 20126e4:	80 a0 60 01 	cmp  %g1, 1                                    
 20126e8:	32 80 00 0d 	bne,a   201271c <fat_file_ioctl+0x88>          
 20126ec:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         
 20126f0:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
 20126f4:	80 a0 60 00 	cmp  %g1, 0                                    
 20126f8:	32 80 00 09 	bne,a   201271c <fat_file_ioctl+0x88>          <== NEVER TAKEN
 20126fc:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         <== NOT EXECUTED
                (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))        
 2012700:	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)) &&                       
 2012704:	80 88 60 03 	btst  3, %g1                                   
 2012708:	22 80 00 05 	be,a   201271c <fat_file_ioctl+0x88>           
 201270c:	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;                                            
 2012710:	c0 27 00 00 	clr  [ %i4 ]                                   
                rc = RC_OK;                                           
                break;                                                
 2012714:	81 c7 e0 08 	ret                                            
 2012718:	91 e8 20 00 	restore  %g0, 0, %o0                           
            }                                                         
                                                                      
            cl_start = pos >> fs_info->vol.bpc_log2;                  
                                                                      
            rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 
 201271c:	90 10 00 18 	mov  %i0, %o0                                  
 2012720:	92 10 00 19 	mov  %i1, %o1                                  
 2012724:	95 36 c0 0a 	srl  %i3, %o2, %o2                             
 2012728:	7f ff fe 72 	call  20120f0 <fat_file_lseek>                 
 201272c:	96 07 bf f8 	add  %fp, -8, %o3                              
            if ( rc != RC_OK )                                        
 2012730:	b0 92 60 00 	orcc  %o1, 0, %i0                              
 2012734:	12 80 00 03 	bne  2012740 <fat_file_ioctl+0xac>             <== NEVER TAKEN
 2012738:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                break;                                                
                                                                      
            *ret = cur_cln;                                           
 201273c:	c2 27 40 00 	st  %g1, [ %i5 ]                               
            break;                                                    
 2012740:	81 c7 e0 08 	ret                                            
 2012744:	81 e8 00 00 	restore                                        
                                                                      
        default:                                                      
            errno = EINVAL;                                           
 2012748:	40 00 23 99 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201274c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012750:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
 2012754:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
            rc = -1;                                                  
 2012758:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
            break;                                                    
    }                                                                 
    va_end(ap);                                                       
    return rc;                                                        
}                                                                     
 201275c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012760:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020120f0 <fat_file_lseek>: fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, uint32_t file_cln, uint32_t *disk_cln ) {
 20120f0:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
 20120f4:	c2 06 60 34 	ld  [ %i1 + 0x34 ], %g1                        
 20120f8:	80 a6 80 01 	cmp  %i2, %g1                                  
 20120fc:	12 80 00 05 	bne  2012110 <fat_file_lseek+0x20>             
 2012100:	01 00 00 00 	nop                                            
        *disk_cln = fat_fd->map.disk_cln;                             
 2012104:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
 2012108:	10 80 00 1b 	b  2012174 <fat_file_lseek+0x84>               
 201210c:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    {                                                                 
        uint32_t   cur_cln;                                           
        uint32_t   count;                                             
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
 2012110:	28 80 00 06 	bleu,a   2012128 <fat_file_lseek+0x38>         
 2012114:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
        {                                                             
            cur_cln = fat_fd->map.disk_cln;                           
 2012118:	c4 06 60 38 	ld  [ %i1 + 0x38 ], %g2                        
            count = file_cln - fat_fd->map.file_cln;                  
 201211c:	b8 26 80 01 	sub  %i2, %g1, %i4                             
        uint32_t   count;                                             
        uint32_t   i;                                                 
                                                                      
        if (file_cln > fat_fd->map.file_cln)                          
        {                                                             
            cur_cln = fat_fd->map.disk_cln;                           
 2012120:	10 80 00 04 	b  2012130 <fat_file_lseek+0x40>               
 2012124:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
            count = file_cln - fat_fd->map.file_cln;                  
        }                                                             
        else                                                          
        {                                                             
            cur_cln = fat_fd->cln;                                    
 2012128:	b8 10 00 1a 	mov  %i2, %i4                                  
 201212c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
 2012130:	10 80 00 0b 	b  201215c <fat_file_lseek+0x6c>               
 2012134:	ba 10 20 00 	clr  %i5                                       
        {                                                             
            rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);     
 2012138:	90 10 00 18 	mov  %i0, %o0                                  
 201213c:	40 00 1d 0c 	call  201956c <fat_get_fat_cluster>            
 2012140:	94 07 bf fc 	add  %fp, -4, %o2                              
            if ( rc != RC_OK )                                        
 2012144:	80 a2 20 00 	cmp  %o0, 0                                    
 2012148:	22 80 00 05 	be,a   201215c <fat_file_lseek+0x6c>           <== ALWAYS TAKEN
 201214c:	ba 07 60 01 	inc  %i5                                       
                return rc;                                            
 2012150:	86 10 00 08 	mov  %o0, %g3                                  <== NOT EXECUTED
 2012154:	10 80 00 0a 	b  201217c <fat_file_lseek+0x8c>               <== NOT EXECUTED
 2012158:	85 3a 20 1f 	sra  %o0, 0x1f, %g2                            <== NOT EXECUTED
            cur_cln = fat_fd->cln;                                    
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
 201215c:	80 a7 40 1c 	cmp  %i5, %i4                                  
 2012160:	12 bf ff f6 	bne  2012138 <fat_file_lseek+0x48>             
 2012164:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
            if ( rc != RC_OK )                                        
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
 2012168:	f4 26 60 34 	st  %i2, [ %i1 + 0x34 ]                        
        fat_fd->map.disk_cln = cur_cln;                               
 201216c:	d2 26 60 38 	st  %o1, [ %i1 + 0x38 ]                        
                                                                      
        *disk_cln = cur_cln;                                          
 2012170:	d2 26 c0 00 	st  %o1, [ %i3 ]                               
    }                                                                 
    return RC_OK;                                                     
 2012174:	84 10 20 00 	clr  %g2                                       
 2012178:	86 10 20 00 	clr  %g3                                       
}                                                                     
 201217c:	b0 10 00 02 	mov  %g2, %i0                                  
 2012180:	81 c7 e0 08 	ret                                            
 2012184:	93 e8 00 03 	restore  %g0, %g3, %o1                         
                                                                      

02012188 <fat_file_open>: fat_file_open( fat_fs_info_t *fs_info, fat_dir_pos_t *dir_pos, fat_file_fd_t **fat_fd ) {
 2012188:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int            rc = RC_OK;                                        
    fat_file_fd_t *lfat_fd = NULL;                                    
    uint32_t       key = 0;                                           
                                                                      
    /* construct key */                                               
    key = fat_construct_key(fs_info, &dir_pos->sname);                
 201218c:	90 10 00 18 	mov  %i0, %o0                                  
 2012190:	7f ff ff c7 	call  20120ac <fat_construct_key>              
 2012194:	92 10 00 19 	mov  %i1, %o1                                  
    uint32_t                               key1,                      
    uint32_t                               key2,                      
    fat_file_fd_t                          **ret                      
    )                                                                 
{                                                                     
    uint32_t          mod = (key1) % FAT_HASH_MODULE;                 
 2012198:	82 0a 20 01 	and  %o0, 1, %g1                               
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
 201219c:	85 28 60 02 	sll  %g1, 2, %g2                               
 20121a0:	b7 28 60 04 	sll  %g1, 4, %i3                               
 20121a4:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        
 20121a8:	b6 26 c0 02 	sub  %i3, %g2, %i3                             
    int            rc = RC_OK;                                        
    fat_file_fd_t *lfat_fd = NULL;                                    
    uint32_t       key = 0;                                           
                                                                      
    /* construct key */                                               
    key = fat_construct_key(fs_info, &dir_pos->sname);                
 20121ac:	b8 10 00 08 	mov  %o0, %i4                                  
    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);       
 20121b0:	a0 00 40 1b 	add  %g1, %i3, %l0                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 20121b4:	fa 00 40 1b 	ld  [ %g1 + %i3 ], %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 ));            
 20121b8:	10 80 00 0c 	b  20121e8 <fat_file_open+0x60>                
 20121bc:	a0 04 20 04 	add  %l0, 4, %l0                               
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
    {                                                                 
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
 20121c0:	7f ff ff bb 	call  20120ac <fat_construct_key>              
 20121c4:	92 07 60 20 	add  %i5, 0x20, %o1                            
                                                                      
        if ( (key1) == ck)                                            
 20121c8:	80 a7 00 08 	cmp  %i4, %o0                                  
 20121cc:	32 80 00 07 	bne,a   20121e8 <fat_file_open+0x60>           
 20121d0:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    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;                                          
        lfat_fd->links_num++;                                         
 20121d4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    /* 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;                                          
 20121d8:	fa 26 80 00 	st  %i5, [ %i2 ]                               
        lfat_fd->links_num++;                                         
 20121dc:	82 00 60 01 	inc  %g1                                       
 20121e0:	10 80 00 42 	b  20122e8 <fat_file_open+0x160>               
 20121e4:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    )                                                                 
{                                                                     
    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) ; )          
 20121e8:	80 a7 40 10 	cmp  %i5, %l0                                  
 20121ec:	12 bf ff f5 	bne  20121c0 <fat_file_open+0x38>              
 20121f0:	90 10 00 18 	mov  %i0, %o0                                  
    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);       
 20121f4:	10 80 00 3f 	b  20122f0 <fat_file_open+0x168>               
 20121f8:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
    {                                                                 
        fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;               
        uint32_t       ck =  fat_construct_key(fs_info, &ffd->dir_pos.sname);
 20121fc:	7f ff ff ac 	call  20120ac <fat_construct_key>              <== NOT EXECUTED
 2012200:	92 07 60 20 	add  %i5, 0x20, %o1                            <== NOT EXECUTED
                                                                      
        if ( (key1) == ck)                                            
 2012204:	80 a7 00 08 	cmp  %i4, %o0                                  <== NOT EXECUTED
 2012208:	32 80 00 0a 	bne,a   2012230 <fat_file_open+0xa8>           <== NOT EXECUTED
 201220c:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
        {                                                             
            if ( ((key2) == 0) || ((key2) == ffd->ino) )              
 2012210:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
 2012214:	22 80 00 0b 	be,a   2012240 <fat_file_open+0xb8>            <== NOT EXECUTED
 2012218:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
 201221c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
 2012220:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
 2012224:	22 80 00 07 	be,a   2012240 <fat_file_open+0xb8>            <== NOT EXECUTED
 2012228:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
 201222c:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== 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) ; )          
 2012230:	80 a7 40 10 	cmp  %i5, %l0                                  
 2012234:	12 bf ff f2 	bne  20121fc <fat_file_open+0x74>              <== NEVER TAKEN
 2012238:	90 10 00 18 	mov  %i0, %o0                                  
 201223c:	a0 10 3f ff 	mov  -1, %l0                                   
    }                                                                 
                                                                      
    /* 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));
 2012240:	7f ff cd 8f 	call  200587c <malloc>                         
 2012244:	90 10 20 44 	mov  0x44, %o0                                 
 2012248:	d0 26 80 00 	st  %o0, [ %i2 ]                               
    if ( lfat_fd == NULL )                                            
 201224c:	80 a2 20 00 	cmp  %o0, 0                                    
 2012250:	02 80 00 1c 	be  20122c0 <fat_file_open+0x138>              <== NEVER TAKEN
 2012254:	ba 10 00 08 	mov  %o0, %i5                                  
        rtems_set_errno_and_return_minus_one( ENOMEM );               
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
 2012258:	92 10 20 00 	clr  %o1                                       
 201225c:	40 00 27 d0 	call  201c19c <memset>                         
 2012260:	94 10 20 44 	mov  0x44, %o2                                 
                                                                      
    lfat_fd->links_num = 1;                                           
 2012264:	82 10 20 01 	mov  1, %g1                                    
 2012268:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
 201226c:	c2 0f 60 30 	ldub  [ %i5 + 0x30 ], %g1                      
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
 2012270:	90 07 60 20 	add  %i5, 0x20, %o0                            
        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;                              
 2012274:	82 08 7f fe 	and  %g1, -2, %g1                              
 2012278:	c2 2f 60 30 	stb  %g1, [ %i5 + 0x30 ]                       
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
 201227c:	82 10 3f ff 	mov  -1, %g1                                   
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
 2012280:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    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;                      
 2012284:	c2 27 60 3c 	st  %g1, [ %i5 + 0x3c ]                        
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
 2012288:	40 00 27 88 	call  201c0a8 <memcpy>                         
 201228c:	94 10 20 10 	mov  0x10, %o2                                 
                                                                      
    if ( rc != RC_OK )                                                
 2012290:	80 a4 20 00 	cmp  %l0, 0                                    
 2012294:	02 80 00 04 	be  20122a4 <fat_file_open+0x11c>              <== NEVER TAKEN
 2012298:	01 00 00 00 	nop                                            
        lfat_fd->ino = key;                                           
 201229c:	10 80 00 0f 	b  20122d8 <fat_file_open+0x150>               
 20122a0:	f8 27 60 0c 	st  %i4, [ %i5 + 0xc ]                         
    else                                                              
    {                                                                 
        lfat_fd->ino = fat_get_unique_ino(fs_info);                   
 20122a4:	40 00 06 aa 	call  2013d4c <fat_get_unique_ino>             <== NOT EXECUTED
 20122a8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
        if ( lfat_fd->ino == 0 )                                      
 20122ac:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 20122b0:	12 80 00 0a 	bne  20122d8 <fat_file_open+0x150>             <== NOT EXECUTED
 20122b4:	d0 27 60 0c 	st  %o0, [ %i5 + 0xc ]                         <== NOT EXECUTED
        {                                                             
            free((*fat_fd));                                          
 20122b8:	7f ff cc 27 	call  2005354 <free>                           <== NOT EXECUTED
 20122bc:	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 );           
 20122c0:	40 00 24 bb 	call  201b5ac <__errno>                        <== NOT EXECUTED
 20122c4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20122c8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
 20122cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 20122d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20122d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 */                                                                   
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);
 20122d8:	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 );                               
 20122dc:	92 10 00 1d 	mov  %i5, %o1                                  
 20122e0:	7f ff e0 33 	call  200a3ac <_Chain_Append>                  
 20122e4:	90 02 00 1b 	add  %o0, %i3, %o0                             
    /*                                                                
     * other fields of fat-file descriptor will be initialized on upper
     * level                                                          
     */                                                               
                                                                      
    return RC_OK;                                                     
 20122e8:	81 c7 e0 08 	ret                                            
 20122ec:	91 e8 20 00 	restore  %g0, 0, %o0                           
    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);       
 20122f0:	a0 00 40 1b 	add  %g1, %i3, %l0                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 20122f4:	fa 00 40 1b 	ld  [ %g1 + %i3 ], %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 ));            
 20122f8:	10 bf ff ce 	b  2012230 <fat_file_open+0xa8>                
 20122fc:	a0 04 20 04 	add  %l0, 4, %l0                               
                                                                      

02012314 <fat_file_read>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, uint8_t *buf ) {
 2012314:	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;                                       
 2012318:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    uint8_t                              *buf                         
)                                                                     
{                                                                     
 201231c:	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)                                                   
 2012320:	80 a6 e0 00 	cmp  %i3, 0                                    
 2012324:	02 80 00 68 	be  20124c4 <fat_file_read+0x1b0>              <== NEVER TAKEN
 2012328:	90 10 20 00 	clr  %o0                                       
                                                                      
    /*                                                                
     * >= because start is offset and computed from 0 and file_size   
     * computed from 1                                                
     */                                                               
    if ( start >= fat_fd->fat_file_size )                             
 201232c:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
 2012330:	80 a6 80 01 	cmp  %i2, %g1                                  
 2012334:	1a 80 00 64 	bcc  20124c4 <fat_file_read+0x1b0>             
 2012338:	80 a6 c0 01 	cmp  %i3, %g1                                  
        return FAT_EOF;                                               
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
 201233c:	38 80 00 07 	bgu,a   2012358 <fat_file_read+0x44>           <== NEVER TAKEN
 2012340:	b6 20 40 1a 	sub  %g1, %i2, %i3                             <== NOT EXECUTED
        (start > fat_fd->fat_file_size - count))                      
 2012344:	84 20 40 1b 	sub  %g1, %i3, %g2                             
     * computed from 1                                                
     */                                                               
    if ( start >= fat_fd->fat_file_size )                             
        return FAT_EOF;                                               
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
 2012348:	80 a6 80 02 	cmp  %i2, %g2                                  
 201234c:	28 80 00 04 	bleu,a   201235c <fat_file_read+0x48>          
 2012350:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
 2012354:	b6 20 40 1a 	sub  %g1, %i2, %i3                             
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
 2012358:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 201235c:	80 a0 60 01 	cmp  %g1, 1                                    
 2012360:	32 80 00 1c 	bne,a   20123d0 <fat_file_read+0xbc>           
 2012364:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         
 2012368:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
 201236c:	80 a0 60 00 	cmp  %g1, 0                                    
 2012370:	32 80 00 18 	bne,a   20123d0 <fat_file_read+0xbc>           <== NEVER TAKEN
 2012374:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
 2012378:	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)) &&                               
 201237c:	80 88 60 03 	btst  3, %g1                                   
 2012380:	22 80 00 14 	be,a   20123d0 <fat_file_read+0xbc>            
 2012384:	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);    
 2012388:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
 201238c:	7f ff ff 3a 	call  2012074 <fat_cluster_num_to_sector_num>  
 2012390:	90 10 00 1d 	mov  %i5, %o0                                  
        sec += (start >> fs_info->vol.sec_log2);                      
 2012394:	d2 0f 60 02 	ldub  [ %i5 + 2 ], %o1                         
        byte = start & (fs_info->vol.bps - 1);                        
 2012398:	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);                      
 201239c:	93 36 80 09 	srl  %i2, %o1, %o1                             
        byte = start & (fs_info->vol.bps - 1);                        
 20123a0:	94 02 bf ff 	add  %o2, -1, %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);                      
 20123a4:	92 02 00 09 	add  %o0, %o1, %o1                             
        byte = start & (fs_info->vol.bps - 1);                        
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, count, buf);        
 20123a8:	94 0e 80 0a 	and  %i2, %o2, %o2                             
 20123ac:	90 10 00 1d 	mov  %i5, %o0                                  
 20123b0:	96 10 00 1b 	mov  %i3, %o3                                  
 20123b4:	40 00 03 13 	call  2013000 <_fat_block_read>                
 20123b8:	98 10 00 1c 	mov  %i4, %o4                                  
        if ( ret < 0 )                                                
 20123bc:	80 a2 20 00 	cmp  %o0, 0                                    
 20123c0:	16 80 00 41 	bge  20124c4 <fat_file_read+0x1b0>             <== ALWAYS TAKEN
 20123c4:	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;                                                
 20123c8:	10 80 00 3f 	b  20124c4 <fat_file_read+0x1b0>               <== NOT EXECUTED
 20123cc:	90 10 3f ff 	mov  -1, %o0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
 20123d0:	f0 17 60 06 	lduh  [ %i5 + 6 ], %i0                         
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
 20123d4:	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);         
 20123d8:	a6 07 bf fc 	add  %fp, -4, %l3                              
 20123dc:	90 10 00 1d 	mov  %i5, %o0                                  
 20123e0:	92 10 00 19 	mov  %i1, %o1                                  
 20123e4:	94 10 00 12 	mov  %l2, %o2                                  
 20123e8:	7f ff ff 42 	call  20120f0 <fat_file_lseek>                 
 20123ec:	96 10 00 13 	mov  %l3, %o3                                  
    if (rc != RC_OK)                                                  
 20123f0:	90 92 60 00 	orcc  %o1, 0, %o0                              
 20123f4:	12 80 00 34 	bne  20124c4 <fat_file_read+0x1b0>             <== NEVER TAKEN
 20123f8:	a0 10 20 00 	clr  %l0                                       
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
 20123fc:	b1 2e 20 10 	sll  %i0, 0x10, %i0                            
 2012400:	b1 36 20 10 	srl  %i0, 0x10, %i0                            
 2012404:	b0 06 3f ff 	add  %i0, -1, %i0                              
 2012408:	b4 0e 80 18 	and  %i2, %i0, %i2                             
 201240c:	b0 10 20 00 	clr  %i0                                       
 2012410:	10 80 00 20 	b  2012490 <fat_file_read+0x17c>               
 2012414:	a2 10 00 1a 	mov  %i2, %l1                                  
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
 2012418:	a0 24 00 11 	sub  %l0, %l1, %l0                             
 201241c:	80 a4 00 1b 	cmp  %l0, %i3                                  
 2012420:	38 80 00 02 	bgu,a   2012428 <fat_file_read+0x114>          
 2012424:	a0 10 00 1b 	mov  %i3, %l0                                  
                                                                      
        sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);        
 2012428:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 201242c:	7f ff ff 12 	call  2012074 <fat_cluster_num_to_sector_num>  
 2012430:	90 10 00 1d 	mov  %i5, %o0                                  
        sec += (ofs >> fs_info->vol.sec_log2);                        
 2012434:	d2 0f 60 02 	ldub  [ %i5 + 2 ], %o1                         
        byte = ofs & (fs_info->vol.bps - 1);                          
 2012438:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
    while (count > 0)                                                 
    {                                                                 
        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);                        
 201243c:	93 34 40 09 	srl  %l1, %o1, %o1                             
        byte = ofs & (fs_info->vol.bps - 1);                          
 2012440:	94 02 bf ff 	add  %o2, -1, %o2                              
    while (count > 0)                                                 
    {                                                                 
        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);                        
 2012444:	92 02 00 09 	add  %o0, %o1, %o1                             
        byte = ofs & (fs_info->vol.bps - 1);                          
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);   
 2012448:	94 0c 40 0a 	and  %l1, %o2, %o2                             
 201244c:	90 10 00 1d 	mov  %i5, %o0                                  
 2012450:	96 10 00 10 	mov  %l0, %o3                                  
 2012454:	40 00 02 eb 	call  2013000 <_fat_block_read>                
 2012458:	98 07 00 18 	add  %i4, %i0, %o4                             
        if ( ret < 0 )                                                
 201245c:	80 a2 20 00 	cmp  %o0, 0                                    
 2012460:	06 80 00 18 	bl  20124c0 <fat_file_read+0x1ac>              <== NEVER TAKEN
 2012464:	b6 26 c0 10 	sub  %i3, %l0, %i3                             
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
 2012468:	b0 06 00 10 	add  %i0, %l0, %i0                             
        save_cln = cur_cln;                                           
 201246c:	e0 07 bf fc 	ld  [ %fp + -4 ], %l0                          
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
 2012470:	90 10 00 1d 	mov  %i5, %o0                                  
 2012474:	92 10 00 10 	mov  %l0, %o1                                  
 2012478:	94 10 00 13 	mov  %l3, %o2                                  
 201247c:	40 00 1c 3c 	call  201956c <fat_get_fat_cluster>            
 2012480:	a2 10 20 00 	clr  %l1                                       
        if ( rc != RC_OK )                                            
 2012484:	80 a2 20 00 	cmp  %o0, 0                                    
 2012488:	12 80 00 0f 	bne  20124c4 <fat_file_read+0x1b0>             <== NEVER TAKEN
 201248c:	01 00 00 00 	nop                                            
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
 2012490:	80 a6 e0 00 	cmp  %i3, 0                                    
 2012494:	32 bf ff e1 	bne,a   2012418 <fat_file_read+0x104>          
 2012498:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
    }                                                                 
                                                                      
    /* 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);
 201249c:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
 20124a0:	b4 06 bf ff 	add  %i2, -1, %i2                              
    fat_fd->map.disk_cln = save_cln;                                  
 20124a4:	e0 26 60 38 	st  %l0, [ %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);
 20124a8:	b4 06 80 18 	add  %i2, %i0, %i2                             
    fat_fd->map.disk_cln = save_cln;                                  
                                                                      
    return cmpltd;                                                    
 20124ac:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
                                                                      
    /* 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);
 20124b0:	b5 36 80 01 	srl  %i2, %g1, %i2                             
        ofs = 0;                                                      
    }                                                                 
                                                                      
    /* update cache */                                                
    /* XXX: check this - I'm not sure :( */                           
    fat_fd->map.file_cln = cl_start +                                 
 20124b4:	a4 06 80 12 	add  %i2, %l2, %l2                             
 20124b8:	10 80 00 03 	b  20124c4 <fat_file_read+0x1b0>               
 20124bc:	e4 26 60 34 	st  %l2, [ %i1 + 0x34 ]                        
        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;                                                
 20124c0:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
    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;                                                    
}                                                                     
 20124c4:	81 c7 e0 08 	ret                                            
 20124c8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

02012c3c <fat_file_size>: int fat_file_size( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
 2012c3c:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = fat_fd->cln;                             
 2012c40:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 2012c44:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    uint32_t       save_cln = 0;                                      
                                                                      
    /* Have we requested root dir size for FAT12/16? */               
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
 2012c48:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 2012c4c:	80 a0 60 01 	cmp  %g1, 1                                    
 2012c50:	12 80 00 0d 	bne  2012c84 <fat_file_size+0x48>              
 2012c54:	ba 10 00 18 	mov  %i0, %i5                                  
 2012c58:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
 2012c5c:	80 a0 60 00 	cmp  %g1, 0                                    
 2012c60:	32 80 00 0a 	bne,a   2012c88 <fat_file_size+0x4c>           <== NEVER TAKEN
 2012c64:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
 2012c68:	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)) &&                               
 2012c6c:	80 88 60 03 	btst  3, %g1                                   
 2012c70:	22 80 00 06 	be,a   2012c88 <fat_file_size+0x4c>            <== ALWAYS TAKEN
 2012c74:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
    {                                                                 
        fat_fd->fat_file_size = fs_info->vol.rdir_size;               
 2012c78:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        <== NOT EXECUTED
 2012c7c:	10 80 00 18 	b  2012cdc <fat_file_size+0xa0>                <== NOT EXECUTED
 2012c80:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        <== NOT EXECUTED
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
 2012c84:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
 2012c88:	10 80 00 0d 	b  2012cbc <fat_file_size+0x80>                
 2012c8c:	82 10 20 00 	clr  %g1                                       
    {                                                                 
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
 2012c90:	92 10 00 1c 	mov  %i4, %o1                                  
 2012c94:	40 00 1a 36 	call  201956c <fat_get_fat_cluster>            
 2012c98:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
 2012c9c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2012ca0:	12 80 00 10 	bne  2012ce0 <fat_file_size+0xa4>              <== NEVER TAKEN
 2012ca4:	01 00 00 00 	nop                                            
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
 2012ca8:	c2 17 60 06 	lduh  [ %i5 + 6 ], %g1                         
 2012cac:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2                        
 2012cb0:	82 00 80 01 	add  %g2, %g1, %g1                             
 2012cb4:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
    {                                                                 
        save_cln = cur_cln;                                           
 2012cb8:	82 10 00 1c 	mov  %i4, %g1                                  
        return rc;                                                    
    }                                                                 
                                                                      
    fat_fd->fat_file_size = 0;                                        
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
 2012cbc:	f8 07 bf fc 	ld  [ %fp + -4 ], %i4                          
 2012cc0:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
 2012cc4:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 2012cc8:	86 0f 00 03 	and  %i4, %g3, %g3                             
 2012ccc:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2012cd0:	0a bf ff f0 	bcs  2012c90 <fat_file_size+0x54>              
 2012cd4:	90 10 00 1d 	mov  %i5, %o0                                  
        if ( rc != RC_OK )                                            
            return rc;                                                
                                                                      
        fat_fd->fat_file_size += fs_info->vol.bpc;                    
    }                                                                 
    fat_fd->map.last_cln = save_cln;                                  
 2012cd8:	c2 26 60 3c 	st  %g1, [ %i1 + 0x3c ]                        
 2012cdc:	b0 10 20 00 	clr  %i0                                       
    return rc;                                                        
}                                                                     
 2012ce0:	81 c7 e0 08 	ret                                            
 2012ce4:	81 e8 00 00 	restore                                        
                                                                      

020124cc <fat_file_truncate>: fat_file_truncate( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, uint32_t new_length ) {
 20124cc:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = 0;                                       
    uint32_t       cl_start = 0;                                      
    uint32_t       new_last_cln = FAT_UNDEFINED_VALUE;                
 20124d0:	82 10 3f ff 	mov  -1, %g1                                   
 20124d4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
 20124d8:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
 20124dc:	80 a6 80 01 	cmp  %i2, %g1                                  
 20124e0:	0a 80 00 04 	bcs  20124f0 <fat_file_truncate+0x24>          
 20124e4:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
        return rc;                                                    
 20124e8:	10 80 00 3b 	b  20125d4 <fat_file_truncate+0x108>           
 20124ec:	92 10 20 00 	clr  %o1                                       
                                                                      
    assert(fat_fd->fat_file_size);                                    
 20124f0:	80 a0 60 00 	cmp  %g1, 0                                    
 20124f4:	32 80 00 0a 	bne,a   201251c <fat_file_truncate+0x50>       <== ALWAYS TAKEN
 20124f8:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
 20124fc:	11 00 80 ad 	sethi  %hi(0x202b400), %o0                     <== NOT EXECUTED
 2012500:	15 00 80 ae 	sethi  %hi(0x202b800), %o2                     <== NOT EXECUTED
 2012504:	17 00 80 ad 	sethi  %hi(0x202b400), %o3                     <== NOT EXECUTED
 2012508:	90 12 23 a8 	or  %o0, 0x3a8, %o0                            <== NOT EXECUTED
 201250c:	92 10 22 d1 	mov  0x2d1, %o1                                <== NOT EXECUTED
 2012510:	94 12 a0 08 	or  %o2, 8, %o2                                <== NOT EXECUTED
 2012514:	40 00 08 82 	call  201471c <__assert_func>                  <== NOT EXECUTED
 2012518:	96 12 e3 f0 	or  %o3, 0x3f0, %o3                            <== NOT EXECUTED
                                                                      
    cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
 201251c:	c6 16 20 06 	lduh  [ %i0 + 6 ], %g3                         
 2012520:	86 00 ff ff 	add  %g3, -1, %g3                              
 2012524:	b4 00 c0 1a 	add  %g3, %i2, %i2                             
 2012528:	b5 36 80 02 	srl  %i2, %g2, %i2                             
                                                                      
    if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size) 
 201252c:	85 2e 80 02 	sll  %i2, %g2, %g2                             
 2012530:	80 a0 80 01 	cmp  %g2, %g1                                  
 2012534:	1a bf ff ed 	bcc  20124e8 <fat_file_truncate+0x1c>          
 2012538:	80 a6 a0 00 	cmp  %i2, 0                                    
        return RC_OK;                                                 
                                                                      
    if (cl_start != 0)                                                
 201253c:	12 80 00 0b 	bne  2012568 <fat_file_truncate+0x9c>          
 2012540:	90 10 00 18 	mov  %i0, %o0                                  
        if (rc != RC_OK)                                              
            return rc;                                                
                                                                      
    }                                                                 
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
 2012544:	92 10 00 19 	mov  %i1, %o1                                  
 2012548:	94 10 00 1a 	mov  %i2, %o2                                  
 201254c:	7f ff fe e9 	call  20120f0 <fat_file_lseek>                 
 2012550:	96 07 bf f8 	add  %fp, -8, %o3                              
    if (rc != RC_OK)                                                  
 2012554:	80 a2 60 00 	cmp  %o1, 0                                    
 2012558:	32 80 00 20 	bne,a   20125d8 <fat_file_truncate+0x10c>      <== NEVER TAKEN
 201255c:	b0 10 00 09 	mov  %o1, %i0                                  <== NOT EXECUTED
        return rc;                                                    
                                                                      
    rc = fat_free_fat_clusters_chain(fs_info, cur_cln);               
 2012560:	10 80 00 0b 	b  201258c <fat_file_truncate+0xc0>            
 2012564:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
    if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size) 
        return RC_OK;                                                 
                                                                      
    if (cl_start != 0)                                                
    {                                                                 
        rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
 2012568:	92 10 00 19 	mov  %i1, %o1                                  
 201256c:	94 06 bf ff 	add  %i2, -1, %o2                              
 2012570:	7f ff fe e0 	call  20120f0 <fat_file_lseek>                 
 2012574:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
 2012578:	80 a2 60 00 	cmp  %o1, 0                                    
 201257c:	02 bf ff f2 	be  2012544 <fat_file_truncate+0x78>           <== ALWAYS TAKEN
 2012580:	90 10 00 18 	mov  %i0, %o0                                  
        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;                                                     
}                                                                     
 2012584:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012588:	91 e8 00 09 	restore  %g0, %o1, %o0                         <== NOT EXECUTED
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    rc = fat_free_fat_clusters_chain(fs_info, cur_cln);               
 201258c:	40 00 1d 0b 	call  20199b8 <fat_free_fat_clusters_chain>    
 2012590:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc != RC_OK)                                                  
 2012594:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2012598:	12 80 00 0f 	bne  20125d4 <fat_file_truncate+0x108>         <== NEVER TAKEN
 201259c:	80 a6 a0 00 	cmp  %i2, 0                                    
        return rc;                                                    
                                                                      
    if (cl_start != 0)                                                
 20125a0:	02 80 00 0d 	be  20125d4 <fat_file_truncate+0x108>          
 20125a4:	92 10 20 00 	clr  %o1                                       
    {                                                                 
        rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
 20125a8:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 20125ac:	90 10 00 18 	mov  %i0, %o0                                  
 20125b0:	40 00 1c 61 	call  2019734 <fat_set_fat_cluster>            
 20125b4:	94 10 3f ff 	mov  -1, %o2                                   
        if ( rc != RC_OK )                                            
 20125b8:	92 92 20 00 	orcc  %o0, 0, %o1                              
 20125bc:	12 80 00 06 	bne  20125d4 <fat_file_truncate+0x108>         <== NEVER TAKEN
 20125c0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
 20125c4:	b4 06 bf ff 	add  %i2, -1, %i2                              
        fat_fd->map.disk_cln = new_last_cln;                          
 20125c8:	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;                          
 20125cc:	f4 26 60 34 	st  %i2, [ %i1 + 0x34 ]                        
        fat_fd->map.disk_cln = new_last_cln;                          
        fat_fd->map.last_cln = new_last_cln;                          
 20125d0:	c2 26 60 3c 	st  %g1, [ %i1 + 0x3c ]                        
    }                                                                 
    return RC_OK;                                                     
}                                                                     
 20125d4:	b0 10 00 09 	mov  %o1, %i0                                  
 20125d8:	81 c7 e0 08 	ret                                            
 20125dc:	81 e8 00 00 	restore                                        
                                                                      

020129bc <fat_file_write>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, const uint8_t *buf ) {
 20129bc:	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;                                             
 20129c0:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    const uint8_t                        *buf                         
    )                                                                 
{                                                                     
 20129c4:	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;         
 20129c8:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t       file_cln_initial = fat_fd->map.file_cln;           
 20129cc:	e6 06 60 34 	ld  [ %i1 + 0x34 ], %l3                        
    uint32_t       cln;                                               
                                                                      
                                                                      
    if ( count == 0 )                                                 
 20129d0:	80 a6 e0 00 	cmp  %i3, 0                                    
 20129d4:	02 80 00 84 	be  2012be4 <fat_file_write+0x228>             <== NEVER TAKEN
 20129d8:	90 10 20 00 	clr  %o0                                       
        return cmpltd;                                                
                                                                      
    if (start >= fat_fd->size_limit)                                  
 20129dc:	fa 06 60 14 	ld  [ %i1 + 0x14 ], %i5                        
 20129e0:	80 a6 80 1d 	cmp  %i2, %i5                                  
 20129e4:	2a 80 00 07 	bcs,a   2012a00 <fat_file_write+0x44>          <== ALWAYS TAKEN
 20129e8:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
        rtems_set_errno_and_return_minus_one(EFBIG);                  
 20129ec:	40 00 22 f0 	call  201b5ac <__errno>                        <== NOT EXECUTED
 20129f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20129f4:	82 10 20 1b 	mov  0x1b, %g1	! 1b <PROM_START+0x1b>          <== NOT EXECUTED
 20129f8:	10 80 00 30 	b  2012ab8 <fat_file_write+0xfc>               <== NOT EXECUTED
 20129fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2012a00:	80 a7 40 1b 	cmp  %i5, %i3                                  
 2012a04:	38 80 00 02 	bgu,a   2012a0c <fat_file_write+0x50>          <== ALWAYS TAKEN
 2012a08:	ba 10 00 1b 	mov  %i3, %i5                                  
    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;         
 2012a0c:	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);
 2012a10:	b6 07 40 1a 	add  %i5, %i2, %i3                             
 2012a14:	94 40 20 00 	addx  %g0, 0, %o2                              
 2012a18:	90 10 00 10 	mov  %l0, %o0                                  
 2012a1c:	92 10 00 19 	mov  %i1, %o1                                  
 2012a20:	96 10 00 1b 	mov  %i3, %o3                                  
 2012a24:	7f ff ff 50 	call  2012764 <fat_file_extend>                
 2012a28:	98 07 bf f8 	add  %fp, -8, %o4                              
    if (RC_OK == rc)                                                  
 2012a2c:	80 a2 20 00 	cmp  %o0, 0                                    
 2012a30:	12 80 00 6d 	bne  2012be4 <fat_file_write+0x228>            
 2012a34:	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))                                     
 2012a38:	80 a0 40 1b 	cmp  %g1, %i3                                  
 2012a3c:	32 80 00 02 	bne,a   2012a44 <fat_file_write+0x88>          <== NEVER TAKEN
 2012a40:	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));
 2012a44:	c6 06 60 20 	ld  [ %i1 + 0x20 ], %g3                        
         */                                                           
        if (c != (start + count))                                     
            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))
 2012a48:	c4 0c 20 0e 	ldub  [ %l0 + 0xe ], %g2                       
 */                                                                   
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));
 2012a4c:	80 a0 e0 01 	cmp  %g3, 1                                    
 2012a50:	12 80 00 09 	bne  2012a74 <fat_file_write+0xb8>             
 2012a54:	82 10 20 00 	clr  %g1                                       
 2012a58:	c6 06 60 24 	ld  [ %i1 + 0x24 ], %g3                        
 2012a5c:	80 a0 e0 00 	cmp  %g3, 0                                    
 2012a60:	12 80 00 06 	bne  2012a78 <fat_file_write+0xbc>             <== NEVER TAKEN
 2012a64:	80 a0 60 00 	cmp  %g1, 0                                    
 2012a68:	82 08 a0 03 	and  %g2, 3, %g1                               
 2012a6c:	80 a0 00 01 	cmp  %g0, %g1                                  
 2012a70:	82 40 20 00 	addx  %g0, 0, %g1                              
         */                                                           
        if (c != (start + count))                                     
            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))
 2012a74:	80 a0 60 00 	cmp  %g1, 0                                    
 2012a78:	02 80 00 12 	be  2012ac0 <fat_file_write+0x104>             
 2012a7c:	f6 0c 20 08 	ldub  [ %l0 + 8 ], %i3                         
        {                                                             
            cln = fat_fd->cln;                                        
 2012a80:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
            cln += (start >> fs_info->vol.bpc_log2);                  
            byte = start & (fs_info->vol.bpc -1);                     
 2012a84:	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);                  
 2012a88:	b7 36 80 1b 	srl  %i2, %i3, %i3                             
            byte = start & (fs_info->vol.bpc -1);                     
 2012a8c:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
            ret = fat_cluster_write(fs_info,                          
 2012a90:	90 10 00 10 	mov  %l0, %o0                                  
 2012a94:	92 06 c0 09 	add  %i3, %o1, %o1                             
 2012a98:	94 0e 80 0a 	and  %i2, %o2, %o2                             
 2012a9c:	96 10 00 1d 	mov  %i5, %o3                                  
 2012aa0:	98 10 00 1c 	mov  %i4, %o4                                  
 2012aa4:	40 00 01 e5 	call  2013238 <fat_cluster_write>              
 2012aa8:	9a 10 20 00 	clr  %o5                                       
                                      cln,                            
                                      byte,                           
                                      count,                          
                                      buf,                            
                                      false);                         
            if (0 > ret)                                              
 2012aac:	80 a2 20 00 	cmp  %o0, 0                                    
 2012ab0:	16 80 00 4d 	bge  2012be4 <fat_file_write+0x228>            <== ALWAYS TAKEN
 2012ab4:	01 00 00 00 	nop                                            
              rc = -1;                                                
 2012ab8:	10 80 00 4b 	b  2012be4 <fat_file_write+0x228>              <== NOT EXECUTED
 2012abc:	90 10 3f ff 	mov  -1, %o0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
     const uint8_t                        *buf,                       
     const uint32_t                        file_cln_initial)          
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
    uint32_t       cur_cln = 0;                                       
 2012ac0:	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;        
 2012ac4:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
    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);        
 2012ac8:	aa 07 bf fc 	add  %fp, -4, %l5                              
{                                                                     
    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;        
 2012acc:	a3 36 80 1b 	srl  %i2, %i3, %l1                             
    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);        
 2012ad0:	90 10 00 10 	mov  %l0, %o0                                  
 2012ad4:	92 10 00 19 	mov  %i1, %o1                                  
 2012ad8:	94 10 00 11 	mov  %l1, %o2                                  
 2012adc:	7f ff fd 85 	call  20120f0 <fat_file_lseek>                 
 2012ae0:	96 10 00 15 	mov  %l5, %o3                                  
    if (RC_OK == rc)                                                  
 2012ae4:	80 a2 60 00 	cmp  %o1, 0                                    
 2012ae8:	12 80 00 34 	bne  2012bb8 <fat_file_write+0x1fc>            <== NEVER TAKEN
 2012aec:	b7 2c 40 1b 	sll  %l1, %i3, %i3                             
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
 2012af0:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 2012af4:	e4 07 bf fc 	ld  [ %fp + -4 ], %l2                          
 2012af8:	a4 24 80 01 	sub  %l2, %g1, %l2                             
    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);
 2012afc:	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;                         
 2012b00:	90 10 20 00 	clr  %o0                                       
    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);
 2012b04:	b0 10 00 1a 	mov  %i2, %i0                                  
    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;                         
 2012b08:	a8 10 20 00 	clr  %l4                                       
     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 */
 2012b0c:	ac 10 20 00 	clr  %l6                                       
     const uint32_t                        count,                     
     const uint8_t                        *buf,                       
     const uint32_t                        file_cln_initial)          
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cmpltd = 0;                                        
 2012b10:	10 80 00 1a 	b  2012b78 <fat_file_write+0x1bc>              
 2012b14:	b6 10 20 00 	clr  %i3                                       
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
        while (   (RC_OK == rc)                                       
               && (bytes_to_write > 0))                               
        {                                                             
            c = MIN(bytes_to_write, (fs_info->vol.bpc - ofs_cln));    
 2012b18:	96 22 c0 18 	sub  %o3, %i0, %o3                             
 2012b1c:	80 a2 c0 1d 	cmp  %o3, %i5                                  
 2012b20:	38 80 00 02 	bgu,a   2012b28 <fat_file_write+0x16c>         
 2012b24:	96 10 00 1d 	mov  %i5, %o3                                  
                                                                      
            if (file_cln_initial < file_cln_cnt)                      
 2012b28:	80 a4 c0 12 	cmp  %l3, %l2                                  
 2012b2c:	2a 80 00 02 	bcs,a   2012b34 <fat_file_write+0x178>         
 2012b30:	a8 10 20 01 	mov  1, %l4                                    
                overwrite_cluster = true;                             
                                                                      
            ret = fat_cluster_write(fs_info,                          
 2012b34:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 2012b38:	90 10 00 10 	mov  %l0, %o0                                  
 2012b3c:	94 10 00 18 	mov  %i0, %o2                                  
 2012b40:	98 07 00 1b 	add  %i4, %i3, %o4                             
 2012b44:	40 00 01 bd 	call  2013238 <fat_cluster_write>              
 2012b48:	9a 0d 20 01 	and  %l4, 1, %o5                               
 2012b4c:	82 10 00 08 	mov  %o0, %g1                                  
                                      cur_cln,                        
                                      ofs_cln,                        
                                      c,                              
                                      &buf[cmpltd],                   
                                      overwrite_cluster);             
            if (0 > ret)                                              
 2012b50:	80 a0 60 00 	cmp  %g1, 0                                    
 2012b54:	16 80 00 1d 	bge  2012bc8 <fat_file_write+0x20c>            <== ALWAYS TAKEN
 2012b58:	90 10 3f ff 	mov  -1, %o0                                   
                                                                      
    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)                                       
 2012b5c:	10 80 00 08 	b  2012b7c <fat_file_write+0x1c0>              <== NOT EXECUTED
 2012b60:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
                ++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);
 2012b64:	90 10 00 10 	mov  %l0, %o0                                  
 2012b68:	92 10 00 16 	mov  %l6, %o1                                  
 2012b6c:	40 00 1a 80 	call  201956c <fat_get_fat_cluster>            
 2012b70:	94 10 00 15 	mov  %l5, %o2                                  
                                                                      
                ofs_cln = 0;                                          
 2012b74:	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)                                       
 2012b78:	80 a7 60 00 	cmp  %i5, 0                                    
 2012b7c:	02 80 00 04 	be  2012b8c <fat_file_write+0x1d0>             
 2012b80:	80 a2 20 00 	cmp  %o0, 0                                    
 2012b84:	22 bf ff e5 	be,a   2012b18 <fat_file_write+0x15c>          <== ALWAYS TAKEN
 2012b88:	d6 14 20 06 	lduh  [ %l0 + 6 ], %o3                         
        }                                                             
                                                                      
        /* 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);
 2012b8c:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
 2012b90:	b4 06 bf ff 	add  %i2, -1, %i2                              
        fat_fd->map.disk_cln = save_cln;                              
 2012b94:	ec 26 60 38 	st  %l6, [ %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);
 2012b98:	b4 06 80 1b 	add  %i2, %i3, %i2                             
 2012b9c:	b5 36 80 01 	srl  %i2, %g1, %i2                             
            }                                                         
        }                                                             
                                                                      
        /* update cache */                                            
        /* XXX: check this - I'm not sure :( */                       
        fat_fd->map.file_cln = start_cln +                            
 2012ba0:	a2 06 80 11 	add  %i2, %l1, %l1                             
                               ((ofs_cln_save + cmpltd - 1) >> fs_info->vol.bpc_log2);
        fat_fd->map.disk_cln = save_cln;                              
    }                                                                 
                                                                      
    if (RC_OK != rc)                                                  
 2012ba4:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2012ba8:	12 80 00 03 	bne  2012bb4 <fat_file_write+0x1f8>            <== NEVER TAKEN
 2012bac:	e2 26 60 34 	st  %l1, [ %i1 + 0x34 ]                        
      return rc;                                                      
    else                                                              
      return cmpltd;                                                  
 2012bb0:	92 10 00 1b 	mov  %i3, %o1                                  
                                                       fat_fd,        
                                                       start,         
                                                       count,         
                                                       buf,           
                                                       file_cln_initial);
            if (0 > ret)                                              
 2012bb4:	80 a2 60 00 	cmp  %o1, 0                                    
 2012bb8:	16 80 00 0b 	bge  2012be4 <fat_file_write+0x228>            <== ALWAYS TAKEN
 2012bbc:	90 10 00 09 	mov  %o1, %o0                                  
 2012bc0:	10 80 00 09 	b  2012be4 <fat_file_write+0x228>              <== NOT EXECUTED
 2012bc4:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
            if (0 > ret)                                              
              rc = -1;                                                
                                                                      
            if (RC_OK == rc)                                          
            {                                                         
                ++file_cln_cnt;                                       
 2012bc8:	a4 04 a0 01 	inc  %l2                                       
                bytes_to_write -= ret;                                
                cmpltd += ret;                                        
 2012bcc:	b6 06 c0 01 	add  %i3, %g1, %i3                             
                save_cln = cur_cln;                                   
                if (0 < bytes_to_write)                               
 2012bd0:	ba a7 40 01 	subcc  %i5, %g1, %i5                           
 2012bd4:	12 bf ff e4 	bne  2012b64 <fat_file_write+0x1a8>            
 2012bd8:	ec 07 bf fc 	ld  [ %fp + -4 ], %l6                          
 2012bdc:	10 bf ff e6 	b  2012b74 <fat_file_write+0x1b8>              
 2012be0:	90 10 20 00 	clr  %o0                                       
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return cmpltd;                                                
}                                                                     
 2012be4:	81 c7 e0 08 	ret                                            
 2012be8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020199b8 <fat_free_fat_clusters_chain>: int fat_free_fat_clusters_chain( fat_fs_info_t *fs_info, uint32_t chain ) {
 20199b8:	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;                                 
 20199bc:	b8 10 20 00 	clr  %i4                                       
int                                                                   
fat_free_fat_clusters_chain(                                          
    fat_fs_info_t                        *fs_info,                    
    uint32_t                              chain                       
    )                                                                 
{                                                                     
 20199c0:	ba 10 00 18 	mov  %i0, %i5                                  
    int            rc = RC_OK, rc1 = RC_OK;                           
    uint32_t       cur_cln = chain;                                   
    uint32_t       next_cln = 0;                                      
 20199c4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    fat_fs_info_t                        *fs_info,                    
    uint32_t                              chain                       
    )                                                                 
{                                                                     
    int            rc = RC_OK, rc1 = RC_OK;                           
    uint32_t       cur_cln = chain;                                   
 20199c8:	b6 10 00 19 	mov  %i1, %i3                                  
    uint32_t       next_cln = 0;                                      
    uint32_t       freed_cls_cnt = 0;                                 
                                                                      
    while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)      
 20199cc:	10 80 00 19 	b  2019a30 <fat_free_fat_clusters_chain+0x78>  
 20199d0:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);        
 20199d4:	92 10 00 1b 	mov  %i3, %o1                                  
 20199d8:	7f ff fe e5 	call  201956c <fat_get_fat_cluster>            
 20199dc:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
 20199e0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20199e4:	02 80 00 0b 	be  2019a10 <fat_free_fat_clusters_chain+0x58> <== ALWAYS TAKEN
 20199e8:	90 10 00 1d 	mov  %i5, %o0                                  
        {                                                             
              if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)        
 20199ec:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        <== NOT EXECUTED
 20199f0:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
 20199f4:	02 80 00 03 	be  2019a00 <fat_free_fat_clusters_chain+0x48> <== NOT EXECUTED
 20199f8:	b8 07 00 01 	add  %i4, %g1, %i4                             <== NOT EXECUTED
                fs_info->vol.free_cls += freed_cls_cnt;               
 20199fc:	f8 27 60 44 	st  %i4, [ %i5 + 0x44 ]                        <== NOT EXECUTED
                                                                      
            fat_buf_release(fs_info);                                 
 2019a00:	7f ff e4 dd 	call  2012d74 <fat_buf_release>                <== NOT EXECUTED
 2019a04:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2019a08:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019a0c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);  
 2019a10:	92 10 00 1b 	mov  %i3, %o1                                  
 2019a14:	7f ff ff 48 	call  2019734 <fat_set_fat_cluster>            
 2019a18:	94 10 20 00 	clr  %o2                                       
        if ( rc != RC_OK )                                            
 2019a1c:	80 a2 20 00 	cmp  %o0, 0                                    
 2019a20:	32 80 00 02 	bne,a   2019a28 <fat_free_fat_clusters_chain+0x70><== NEVER TAKEN
 2019a24:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
            rc1 = rc;                                                 
                                                                      
        freed_cls_cnt++;                                              
        cur_cln = next_cln;                                           
 2019a28:	f6 07 bf fc 	ld  [ %fp + -4 ], %i3                          
                                                                      
        rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);  
        if ( rc != RC_OK )                                            
            rc1 = rc;                                                 
                                                                      
        freed_cls_cnt++;                                              
 2019a2c:	b8 07 20 01 	inc  %i4                                       
    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)      
 2019a30:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
 2019a34:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2019a38:	84 0e c0 02 	and  %i3, %g2, %g2                             
 2019a3c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2019a40:	0a bf ff e5 	bcs  20199d4 <fat_free_fat_clusters_chain+0x1c>
 2019a44:	90 10 00 1d 	mov  %i5, %o0                                  
        freed_cls_cnt++;                                              
        cur_cln = next_cln;                                           
    }                                                                 
                                                                      
        fs_info->vol.next_cl = chain;                                 
        if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)             
 2019a48:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
 2019a4c:	80 a0 7f ff 	cmp  %g1, -1                                   
 2019a50:	02 80 00 05 	be  2019a64 <fat_free_fat_clusters_chain+0xac> <== ALWAYS TAKEN
 2019a54:	f2 27 60 4c 	st  %i1, [ %i5 + 0x4c ]                        
            fs_info->vol.free_cls += freed_cls_cnt;                   
 2019a58:	b8 07 00 01 	add  %i4, %g1, %i4                             <== NOT EXECUTED
 2019a5c:	f8 27 60 44 	st  %i4, [ %i5 + 0x44 ]                        <== NOT EXECUTED
                                                                      
    fat_buf_release(fs_info);                                         
 2019a60:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2019a64:	7f ff e4 c4 	call  2012d74 <fat_buf_release>                
 2019a68:	b0 10 00 1a 	mov  %i2, %i0                                  
    if (rc1 != RC_OK)                                                 
        return rc1;                                                   
                                                                      
    return RC_OK;                                                     
}                                                                     
 2019a6c:	81 c7 e0 08 	ret                                            
 2019a70:	81 e8 00 00 	restore                                        
                                                                      

02013e0c <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);
 2013e0c:	c2 02 20 80 	ld  [ %o0 + 0x80 ], %g1                        <== NOT EXECUTED
 2013e10:	c4 02 20 74 	ld  [ %o0 + 0x74 ], %g2                        <== NOT EXECUTED
 2013e14:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
 2013e18:	92 22 40 01 	sub  %o1, %g1, %o1                             <== NOT EXECUTED
 2013e1c:	83 32 60 03 	srl  %o1, 3, %g1                               <== NOT EXECUTED
 2013e20:	92 0a 60 07 	and  %o1, 7, %o1                               <== NOT EXECUTED
 2013e24:	93 28 c0 09 	sll  %g3, %o1, %o1                             <== NOT EXECUTED
 2013e28:	c6 08 80 01 	ldub  [ %g2 + %g1 ], %g3                       <== NOT EXECUTED
 2013e2c:	92 28 c0 09 	andn  %g3, %o1, %o1                            <== NOT EXECUTED
 2013e30:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2013e34:	d2 28 80 01 	stb  %o1, [ %g2 + %g1 ]                        <== NOT EXECUTED
                                                                      

0201956c <fat_get_fat_cluster>: fat_get_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t *ret_val ) {
 201956c:	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)) )           
 2019570:	80 a6 60 01 	cmp  %i1, 1                                    
 2019574:	08 80 00 67 	bleu  2019710 <fat_get_fat_cluster+0x1a4>      <== NEVER TAKEN
 2019578:	ba 10 00 18 	mov  %i0, %i5                                  
 201957c:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
 2019580:	82 00 60 01 	inc  %g1                                       
 2019584:	80 a6 40 01 	cmp  %i1, %g1                                  
 2019588:	28 80 00 03 	bleu,a   2019594 <fat_get_fat_cluster+0x28>    <== ALWAYS TAKEN
 201958c:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
 2019590:	30 80 00 60 	b,a   2019710 <fat_get_fat_cluster+0x1a4>      <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
 2019594:	86 08 60 01 	and  %g1, 1, %g3                               
 2019598:	80 88 e0 ff 	btst  0xff, %g3                                
 201959c:	02 80 00 05 	be  20195b0 <fat_get_fat_cluster+0x44>         
 20195a0:	88 08 60 02 	and  %g1, 2, %g4                               
 20195a4:	85 36 60 01 	srl  %i1, 1, %g2                               
 20195a8:	10 80 00 06 	b  20195c0 <fat_get_fat_cluster+0x54>          
 20195ac:	84 00 80 19 	add  %g2, %i1, %g2                             
 20195b0:	80 89 20 ff 	btst  0xff, %g4                                
 20195b4:	02 80 00 03 	be  20195c0 <fat_get_fat_cluster+0x54>         
 20195b8:	85 2e 60 02 	sll  %i1, 2, %g2                               
 20195bc:	85 2e 60 01 	sll  %i1, 1, %g2                               
 20195c0:	f6 0f 60 02 	ldub  [ %i5 + 2 ], %i3                         
 20195c4:	c8 07 60 58 	ld  [ %i5 + 0x58 ], %g4                        
 20195c8:	85 30 80 1b 	srl  %g2, %i3, %g2                             
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
 20195cc:	80 88 e0 ff 	btst  0xff, %g3                                
 20195d0:	02 80 00 05 	be  20195e4 <fat_get_fat_cluster+0x78>         
 20195d4:	b6 00 80 04 	add  %g2, %g4, %i3                             
 20195d8:	b9 36 60 01 	srl  %i1, 1, %i4                               
 20195dc:	10 80 00 07 	b  20195f8 <fat_get_fat_cluster+0x8c>          
 20195e0:	b8 07 00 19 	add  %i4, %i1, %i4                             
 20195e4:	82 08 60 02 	and  %g1, 2, %g1                               
 20195e8:	80 88 60 ff 	btst  0xff, %g1                                
 20195ec:	02 80 00 03 	be  20195f8 <fat_get_fat_cluster+0x8c>         
 20195f0:	b9 2e 60 02 	sll  %i1, 2, %i4                               
 20195f4:	b9 2e 60 01 	sll  %i1, 1, %i4                               
 20195f8:	e0 17 40 00 	lduh  [ %i5 ], %l0                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
 20195fc:	90 10 00 1d 	mov  %i5, %o0                                  
 2019600:	92 10 00 1b 	mov  %i3, %o1                                  
 2019604:	94 10 20 01 	mov  1, %o2                                    
 2019608:	7f ff e6 4f 	call  2012f44 <fat_buf_access>                 
 201960c:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
 2019610:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2019614:	12 80 00 37 	bne  20196f0 <fat_get_fat_cluster+0x184>       <== NEVER TAKEN
 2019618:	83 2c 20 10 	sll  %l0, 0x10, %g1                            
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
 201961c:	c4 0f 60 0e 	ldub  [ %i5 + 0xe ], %g2                       
 2019620:	80 a0 a0 02 	cmp  %g2, 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);
 2019624:	83 30 60 10 	srl  %g1, 0x10, %g1                            
 2019628:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
 201962c:	02 80 00 27 	be  20196c8 <fat_get_fat_cluster+0x15c>        
 2019630:	82 0f 00 01 	and  %i4, %g1, %g1                             
 2019634:	80 a0 a0 04 	cmp  %g2, 4                                    
 2019638:	02 80 00 30 	be  20196f8 <fat_get_fat_cluster+0x18c>        
 201963c:	80 a0 a0 01 	cmp  %g2, 1                                    
 2019640:	12 80 00 34 	bne  2019710 <fat_get_fat_cluster+0x1a4>       <== NEVER TAKEN
 2019644:	c6 07 bf fc 	ld  [ %fp + -4 ], %g3                          
            /*                                                        
             * 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) )                      
 2019648:	c8 17 40 00 	lduh  [ %i5 ], %g4                             
        case FAT_FAT12:                                               
            /*                                                        
             * we are enforced in complex computations for FAT12 to escape CPU
             * align problems for some architectures                  
             */                                                       
            *ret_val = (*(sec_buf + ofs));                            
 201964c:	c4 08 c0 01 	ldub  [ %g3 + %g1 ], %g2                       
            if ( ofs == (fs_info->vol.bps - 1) )                      
 2019650:	88 01 3f ff 	add  %g4, -1, %g4                              
 2019654:	80 a0 40 04 	cmp  %g1, %g4                                  
 2019658:	12 80 00 10 	bne  2019698 <fat_get_fat_cluster+0x12c>       <== ALWAYS TAKEN
 201965c:	c4 26 80 00 	st  %g2, [ %i2 ]                               
            {                                                         
                rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
 2019660:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2019664:	92 06 e0 01 	add  %i3, 1, %o1                               <== NOT EXECUTED
 2019668:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 201966c:	7f ff e6 36 	call  2012f44 <fat_buf_access>                 <== NOT EXECUTED
 2019670:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                    &sec_buf);                        
                if (rc != RC_OK)                                      
 2019674:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2019678:	12 80 00 2c 	bne  2019728 <fat_get_fat_cluster+0x1bc>       <== NOT EXECUTED
 201967c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                    return rc;                                        
                                                                      
                *ret_val |= *sec_buf << 8;                            
 2019680:	c4 06 80 00 	ld  [ %i2 ], %g2                               <== NOT EXECUTED
 2019684:	c2 08 40 00 	ldub  [ %g1 ], %g1                             <== NOT EXECUTED
 2019688:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
 201968c:	82 10 80 01 	or  %g2, %g1, %g1                              <== NOT EXECUTED
 2019690:	10 80 00 07 	b  20196ac <fat_get_fat_cluster+0x140>         <== NOT EXECUTED
 2019694:	c2 26 80 00 	st  %g1, [ %i2 ]                               <== NOT EXECUTED
            }                                                         
            else                                                      
            {                                                         
                *ret_val |= *(sec_buf + ofs + 1) << 8;                
 2019698:	82 00 c0 01 	add  %g3, %g1, %g1                             
 201969c:	c2 08 60 01 	ldub  [ %g1 + 1 ], %g1                         
 20196a0:	83 28 60 08 	sll  %g1, 8, %g1                               
 20196a4:	84 10 40 02 	or  %g1, %g2, %g2                              
 20196a8:	c4 26 80 00 	st  %g2, [ %i2 ]                               
            }                                                         
                                                                      
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
 20196ac:	80 8e 60 01 	btst  1, %i1                                   
 20196b0:	02 80 00 04 	be  20196c0 <fat_get_fat_cluster+0x154>        
 20196b4:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                *ret_val = (*ret_val) >> FAT12_SHIFT;                 
 20196b8:	10 80 00 0d 	b  20196ec <fat_get_fat_cluster+0x180>         
 20196bc:	83 30 60 04 	srl  %g1, 4, %g1                               
            else                                                      
                *ret_val = (*ret_val) & FAT_FAT12_MASK;               
 20196c0:	10 80 00 0b 	b  20196ec <fat_get_fat_cluster+0x180>         
 20196c4:	82 08 6f ff 	and  %g1, 0xfff, %g1                           
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *ret_val = *((uint16_t   *)(sec_buf + ofs));              
 20196c8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
            *ret_val = CF_LE_W(*ret_val);                             
 20196cc:	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));              
 20196d0:	c2 10 80 01 	lduh  [ %g2 + %g1 ], %g1                       
            *ret_val = CF_LE_W(*ret_val);                             
 20196d4:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
 20196d8:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 20196dc:	85 30 60 18 	srl  %g1, 0x18, %g2                            
 20196e0:	83 30 60 08 	srl  %g1, 8, %g1                               
 20196e4:	82 08 40 03 	and  %g1, %g3, %g1                             
 20196e8:	82 10 80 01 	or  %g2, %g1, %g1                              
 20196ec:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
 20196f0:	81 c7 e0 08 	ret                                            
 20196f4:	81 e8 00 00 	restore                                        
                                                                      
        case FAT_FAT32:                                               
            *ret_val = *((uint32_t   *)(sec_buf + ofs));              
            *ret_val = CF_LE_L(*ret_val);                             
 20196f8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
 20196fc:	7f ff ff 90 	call  201953c <CPU_swap_u32>                   
 2019700:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0                         
 2019704:	d0 26 80 00 	st  %o0, [ %i2 ]                               
            break;                                                    
 2019708:	81 c7 e0 08 	ret                                            
 201970c:	81 e8 00 00 	restore                                        
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
 2019710:	40 00 07 a7 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2019714:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2019718:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201971c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2019720:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019724:	81 e8 00 00 	restore                                        <== NOT EXECUTED
            *ret_val = (*(sec_buf + ofs));                            
            if ( ofs == (fs_info->vol.bps - 1) )                      
            {                                                         
                rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
                                    &sec_buf);                        
                if (rc != RC_OK)                                      
 2019728:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
            break;                                                    
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
 201972c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019730:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02013d4c <fat_get_unique_ino>: * 0 means FAILED !!! * */ uint32_t fat_get_unique_ino(fat_fs_info_t *fs_info) {
 2013d4c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== 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))
 2013d50:	39 03 ff ff 	sethi  %hi(0xffffc00), %i4                     <== NOT EXECUTED
fat_get_unique_ino(fat_fs_info_t *fs_info)                            
{                                                                     
    uint32_t                j = 0;                                    
    bool                    resrc_unsuff = false;                     
                                                                      
    while (!resrc_unsuff)                                             
 2013d54:	10 80 00 2b 	b  2013e00 <fat_get_unique_ino+0xb4>           <== NOT EXECUTED
 2013d58:	b8 17 23 ff 	or  %i4, 0x3ff, %i4	! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
    {                                                                 
        for (j = 0; j < fs_info->uino_pool_size; j++)                 
        {                                                             
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
 2013d5c:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        <== NOT EXECUTED
 2013d60:	85 30 60 03 	srl  %g1, 3, %g2                               <== NOT EXECUTED
 2013d64:	b6 00 c0 02 	add  %g3, %g2, %i3                             <== NOT EXECUTED
 2013d68:	f4 08 c0 02 	ldub  [ %g3 + %g2 ], %i2                       <== NOT EXECUTED
 2013d6c:	c4 48 c0 02 	ldsb  [ %g3 + %g2 ], %g2                       <== NOT EXECUTED
 2013d70:	ba 08 60 07 	and  %g1, 7, %i5                               <== NOT EXECUTED
 2013d74:	85 38 80 1d 	sra  %g2, %i5, %g2                             <== NOT EXECUTED
 2013d78:	80 88 a0 01 	btst  1, %g2                                   <== NOT EXECUTED
 2013d7c:	12 80 00 0a 	bne  2013da4 <fat_get_unique_ino+0x58>         <== NOT EXECUTED
 2013d80:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
            {                                                         
                FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino); 
 2013d84:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2013d88:	bb 28 40 1d 	sll  %g1, %i5, %i5                             <== NOT EXECUTED
 2013d8c:	ba 17 40 1a 	or  %i5, %i2, %i5                              <== NOT EXECUTED
 2013d90:	fa 2e c0 00 	stb  %i5, [ %i3 ]                              <== NOT EXECUTED
                return (fs_info->uino_base + fs_info->index);         
 2013d94:	c4 06 20 78 	ld  [ %i0 + 0x78 ], %g2                        <== NOT EXECUTED
 2013d98:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
 2013d9c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013da0:	91 e8 80 01 	restore  %g2, %g1, %o0                         <== NOT EXECUTED
            }                                                         
            fs_info->index++;                                         
            if (fs_info->index >= fs_info->uino_pool_size)            
 2013da4:	80 a0 40 04 	cmp  %g1, %g4                                  <== NOT EXECUTED
 2013da8:	3a 80 00 03 	bcc,a   2013db4 <fat_get_unique_ino+0x68>      <== NOT EXECUTED
 2013dac:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            <== NOT EXECUTED
 2013db0:	c2 26 20 78 	st  %g1, [ %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++)                 
 2013db4:	92 02 60 01 	inc  %o1                                       <== NOT EXECUTED
 2013db8:	80 a2 40 04 	cmp  %o1, %g4                                  <== NOT EXECUTED
 2013dbc:	32 bf ff e8 	bne,a   2013d5c <fat_get_unique_ino+0x10>      <== NOT EXECUTED
 2013dc0:	c6 06 20 74 	ld  [ %i0 + 0x74 ], %g3                        <== 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))
 2013dc4:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
 2013dc8:	93 2a 60 01 	sll  %o1, 1, %o1                               <== NOT EXECUTED
 2013dcc:	82 27 00 01 	sub  %i4, %g1, %g1                             <== NOT EXECUTED
 2013dd0:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
 2013dd4:	2a 80 00 04 	bcs,a   2013de4 <fat_get_unique_ino+0x98>      <== NOT EXECUTED
 2013dd8:	d0 06 20 74 	ld  [ %i0 + 0x74 ], %o0                        <== NOT EXECUTED
                resrc_unsuff = true;                                  
        }                                                             
        else                                                          
            resrc_unsuff = true;                                      
    }                                                                 
    return 0;                                                         
 2013ddc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013de0:	91 e8 20 00 	restore  %g0, 0, %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);
 2013de4:	7f ff c9 6c 	call  2006394 <realloc>                        <== NOT EXECUTED
 2013de8:	d2 26 20 7c 	st  %o1, [ %i0 + 0x7c ]                        <== NOT EXECUTED
            if (fs_info->uino != NULL)                                
 2013dec:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2013df0:	02 bf ff fb 	be  2013ddc <fat_get_unique_ino+0x90>          <== NOT EXECUTED
 2013df4:	d0 26 20 74 	st  %o0, [ %i0 + 0x74 ]                        <== NOT EXECUTED
                fs_info->index = fs_info->uino_pool_size;             
 2013df8:	c2 06 20 7c 	ld  [ %i0 + 0x7c ], %g1                        <== NOT EXECUTED
 2013dfc:	c2 26 20 78 	st  %g1, [ %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++)                 
 2013e00:	c8 06 20 7c 	ld  [ %i0 + 0x7c ], %g4                        <== NOT EXECUTED
 2013e04:	10 bf ff ed 	b  2013db8 <fat_get_unique_ino+0x6c>           <== NOT EXECUTED
 2013e08:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
                                                                      

02013cd4 <fat_init_clusters_chain>: int fat_init_clusters_chain( fat_fs_info_t *fs_info, uint32_t start_cln ) {
 2013cd4:	9d e3 bf 98 	save  %sp, -104, %sp                           
 2013cd8:	ba 10 00 18 	mov  %i0, %i5                                  
    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)      
 2013cdc:	10 80 00 10 	b  2013d1c <fat_init_clusters_chain+0x48>      
 2013ce0:	f2 27 bf fc 	st  %i1, [ %fp + -4 ]                          
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
 2013ce4:	90 10 00 1d 	mov  %i5, %o0                                  
 2013ce8:	94 10 20 00 	clr  %o2                                       
 2013cec:	7f ff fd 0b 	call  2013118 <fat_cluster_set>                
 2013cf0:	98 10 20 00 	clr  %o4                                       
        if ( ret != fs_info->vol.bpc )                                
 2013cf4:	c2 17 60 06 	lduh  [ %i5 + 6 ], %g1                         
 2013cf8:	80 a2 00 01 	cmp  %o0, %g1                                  
 2013cfc:	12 80 00 11 	bne  2013d40 <fat_init_clusters_chain+0x6c>    <== NEVER TAKEN
 2013d00:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
        {                                                             
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);        
 2013d04:	90 10 00 1d 	mov  %i5, %o0                                  
 2013d08:	40 00 16 19 	call  201956c <fat_get_fat_cluster>            
 2013d0c:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
 2013d10:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2013d14:	12 80 00 0c 	bne  2013d44 <fat_init_clusters_chain+0x70>    <== NEVER TAKEN
 2013d18:	01 00 00 00 	nop                                            
{                                                                     
    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)      
 2013d1c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 2013d20:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
 2013d24:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2013d28:	84 0a 40 02 	and  %o1, %g2, %g2                             
 2013d2c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2013d30:	2a bf ff ed 	bcs,a   2013ce4 <fat_init_clusters_chain+0x10> 
 2013d34:	d6 17 60 06 	lduh  [ %i5 + 6 ], %o3                         
            return rc;                                                
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
 2013d38:	81 c7 e0 08 	ret                                            
 2013d3c:	91 e8 20 00 	restore  %g0, 0, %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;                                                
 2013d40:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
 2013d44:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013d48:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02013364 <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) {
 2013364:	9d e3 bf 08 	save  %sp, -248, %sp                           
    ssize_t             ret = 0;                                      
    struct stat         stat_buf;                                     
    int                 i = 0;                                        
    rtems_bdbuf_buffer *block = NULL;                                 
                                                                      
    vol->fd = open(device, O_RDWR);                                   
 2013368:	92 10 20 02 	mov  2, %o1                                    
 *     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)      
{                                                                     
 201336c:	b6 10 00 18 	mov  %i0, %i3                                  
    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;                                 
 2013370:	c0 27 bf a4 	clr  [ %fp + -92 ]                             
                                                                      
    vol->fd = open(device, O_RDWR);                                   
 2013374:	7f ff cb 6d 	call  2006128 <open>                           
 2013378:	90 10 00 19 	mov  %i1, %o0                                  
    if (vol->fd < 0)                                                  
 201337c:	80 a2 20 00 	cmp  %o0, 0                                    
 2013380:	06 80 00 17 	bl  20133dc <fat_init_volume_info+0x78>        <== NEVER TAKEN
 2013384:	d0 26 e0 60 	st  %o0, [ %i3 + 0x60 ]                        
    {                                                                 
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    rc = fstat(vol->fd, &stat_buf);                                   
 2013388:	7f ff c8 1d 	call  20053fc <fstat>                          
 201338c:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rc != 0)                                                      
 2013390:	80 a2 20 00 	cmp  %o0, 0                                    
 2013394:	12 80 00 10 	bne  20133d4 <fat_init_volume_info+0x70>       <== NEVER TAKEN
 2013398:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    /* Must be a block device. */                                     
    if (!S_ISBLK(stat_buf.st_mode))                                   
 201339c:	c6 07 bf c4 	ld  [ %fp + -60 ], %g3                         
 20133a0:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
 20133a4:	86 08 c0 02 	and  %g3, %g2, %g3                             
 20133a8:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
 20133ac:	80 a0 c0 02 	cmp  %g3, %g2                                  
 20133b0:	12 80 00 09 	bne  20133d4 <fat_init_volume_info+0x70>       <== NEVER TAKEN
 20133b4:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
static inline int rtems_disk_fd_get_disk_device(                      
  int fd,                                                             
  rtems_disk_device **dd_ptr                                          
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
 20133b8:	94 06 20 64 	add  %i0, 0x64, %o2                            
 20133bc:	40 00 05 97 	call  2014a18 <ioctl>                          
 20133c0:	92 12 62 09 	or  %o1, 0x209, %o1                            
        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) {                                                    
 20133c4:	80 a2 20 00 	cmp  %o0, 0                                    
 20133c8:	22 80 00 09 	be,a   20133ec <fat_init_volume_info+0x88>     <== ALWAYS TAKEN
 20133cc:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
        close(vol->fd);                                               
 20133d0:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
 20133d4:	7f ff c7 23 	call  2005060 <close>                          <== NOT EXECUTED
 20133d8:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENXIO);                  
 20133dc:	40 00 20 74 	call  201b5ac <__errno>                        <== NOT EXECUTED
 20133e0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20133e4:	10 80 01 af 	b  2013aa0 <fat_init_volume_info+0x73c>        <== NOT EXECUTED
 20133e8:	82 10 20 06 	mov  6, %g1	! 6 <PROM_START+0x6>               <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Read boot record */                                            
    /* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */          
    sc = rtems_bdbuf_read( vol->dd, 0, &block);                       
 20133ec:	92 10 20 00 	clr  %o1                                       
 20133f0:	7f ff f6 9a 	call  2010e58 <rtems_bdbuf_read>               
 20133f4:	94 07 bf a4 	add  %fp, -92, %o2                             
    if (sc != RTEMS_SUCCESSFUL)                                       
 20133f8:	80 a2 20 00 	cmp  %o0, 0                                    
 20133fc:	22 80 00 03 	be,a   2013408 <fat_init_volume_info+0xa4>     <== ALWAYS TAKEN
 2013400:	d0 07 bf a4 	ld  [ %fp + -92 ], %o0                         
 2013404:	30 80 00 32 	b,a   20134cc <fat_init_volume_info+0x168>     <== NOT EXECUTED
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one( EIO);                   
    }                                                                 
                                                                      
    memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);               
 2013408:	c6 02 20 1c 	ld  [ %o0 + 0x1c ], %g3                        
 201340c:	c2 08 e0 20 	ldub  [ %g3 + 0x20 ], %g1                      
 2013410:	c4 08 e0 0b 	ldub  [ %g3 + 0xb ], %g2                       
 2013414:	c2 2f bf 9a 	stb  %g1, [ %fp + -102 ]                       
 2013418:	c2 08 e0 23 	ldub  [ %g3 + 0x23 ], %g1                      
 201341c:	d2 08 e0 0c 	ldub  [ %g3 + 0xc ], %o1                       
 2013420:	c2 2f bf 8f 	stb  %g1, [ %fp + -113 ]                       
 2013424:	c2 08 e0 2c 	ldub  [ %g3 + 0x2c ], %g1                      
 2013428:	d8 08 e0 0e 	ldub  [ %g3 + 0xe ], %o4                       
 201342c:	c2 2f bf 9d 	stb  %g1, [ %fp + -99 ]                        
 2013430:	c2 08 e0 2d 	ldub  [ %g3 + 0x2d ], %g1                      
 2013434:	d6 08 e0 0f 	ldub  [ %g3 + 0xf ], %o3                       
 2013438:	c2 2f bf 9c 	stb  %g1, [ %fp + -100 ]                       
 201343c:	c2 08 e0 2e 	ldub  [ %g3 + 0x2e ], %g1                      
 2013440:	c8 08 e0 11 	ldub  [ %g3 + 0x11 ], %g4                      
 2013444:	c2 2f bf 9b 	stb  %g1, [ %fp + -101 ]                       
 2013448:	c2 08 e0 2f 	ldub  [ %g3 + 0x2f ], %g1                      
 201344c:	da 08 e0 12 	ldub  [ %g3 + 0x12 ], %o5                      
 2013450:	c2 2f bf 97 	stb  %g1, [ %fp + -105 ]                       
 2013454:	c2 08 e0 30 	ldub  [ %g3 + 0x30 ], %g1                      
 2013458:	fa 08 e0 0d 	ldub  [ %g3 + 0xd ], %i5                       
 201345c:	f4 08 e0 10 	ldub  [ %g3 + 0x10 ], %i2                      
 2013460:	e2 08 e0 13 	ldub  [ %g3 + 0x13 ], %l1                      
 2013464:	e4 08 e0 14 	ldub  [ %g3 + 0x14 ], %l2                      
 2013468:	ee 08 e0 16 	ldub  [ %g3 + 0x16 ], %l7                      
 201346c:	f0 08 e0 17 	ldub  [ %g3 + 0x17 ], %i0                      
 2013470:	e0 08 e0 21 	ldub  [ %g3 + 0x21 ], %l0                      
 2013474:	f2 08 e0 22 	ldub  [ %g3 + 0x22 ], %i1                      
 2013478:	e8 08 e0 24 	ldub  [ %g3 + 0x24 ], %l4                      
 201347c:	ec 08 e0 25 	ldub  [ %g3 + 0x25 ], %l6                      
 2013480:	ea 08 e0 26 	ldub  [ %g3 + 0x26 ], %l5                      
 2013484:	e6 08 e0 27 	ldub  [ %g3 + 0x27 ], %l3                      
 2013488:	f8 08 e0 28 	ldub  [ %g3 + 0x28 ], %i4                      
 201348c:	c2 2f bf 9f 	stb  %g1, [ %fp + -97 ]                        
 2013490:	c6 08 e0 31 	ldub  [ %g3 + 0x31 ], %g3                      
                                                                      
    sc = rtems_bdbuf_release( block);                                 
 2013494:	c4 27 bf 80 	st  %g2, [ %fp + -128 ]                        
 2013498:	c8 27 bf 7c 	st  %g4, [ %fp + -132 ]                        
 201349c:	d2 27 bf 78 	st  %o1, [ %fp + -136 ]                        
 20134a0:	d6 27 bf 74 	st  %o3, [ %fp + -140 ]                        
 20134a4:	d8 3f bf 68 	std  %o4, [ %fp + -152 ]                       
 20134a8:	7f ff f6 e8 	call  2011048 <rtems_bdbuf_release>            
 20134ac:	c6 2f bf 9e 	stb  %g3, [ %fp + -98 ]                        
    if (sc != RTEMS_SUCCESSFUL)                                       
 20134b0:	c4 07 bf 80 	ld  [ %fp + -128 ], %g2                        
 20134b4:	80 a2 20 00 	cmp  %o0, 0                                    
 20134b8:	c8 07 bf 7c 	ld  [ %fp + -132 ], %g4                        
 20134bc:	d2 07 bf 78 	ld  [ %fp + -136 ], %o1                        
 20134c0:	d6 07 bf 74 	ld  [ %fp + -140 ], %o3                        
 20134c4:	02 80 00 08 	be  20134e4 <fat_init_volume_info+0x180>       <== ALWAYS TAKEN
 20134c8:	d8 1f bf 68 	ldd  [ %fp + -152 ], %o4                       
    {                                                                 
        close(vol->fd);                                               
 20134cc:	7f ff c6 e5 	call  2005060 <close>                          <== NOT EXECUTED
 20134d0:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
 20134d4:	40 00 20 36 	call  201b5ac <__errno>                        <== NOT EXECUTED
 20134d8:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20134dc:	10 80 01 71 	b  2013aa0 <fat_init_volume_info+0x73c>        <== NOT EXECUTED
 20134e0:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Evaluate boot record */                                        
    vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);                 
 20134e4:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
 20134e8:	92 0a 60 ff 	and  %o1, 0xff, %o1                            
 20134ec:	93 2a 60 08 	sll  %o1, 8, %o1                               
 20134f0:	92 12 40 02 	or  %o1, %g2, %o1                              
 20134f4:	d2 36 c0 00 	sth  %o1, [ %i3 ]                              
                                                                      
    if ( (vol->bps != 512)  &&                                        
 20134f8:	85 2a 60 10 	sll  %o1, 0x10, %g2                            
 20134fc:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
 2013500:	80 a0 a4 00 	cmp  %g2, 0x400                                
 2013504:	02 80 00 0c 	be  2013534 <fat_init_volume_info+0x1d0>       <== NEVER TAKEN
 2013508:	86 10 00 09 	mov  %o1, %g3                                  
 201350c:	80 a0 a2 00 	cmp  %g2, 0x200                                
 2013510:	22 80 00 0a 	be,a   2013538 <fat_init_volume_info+0x1d4>    <== ALWAYS TAKEN
 2013514:	85 2a 60 10 	sll  %o1, 0x10, %g2                            
         (vol->bps != 1024) &&                                        
 2013518:	80 a0 a8 00 	cmp  %g2, 0x800                                <== NOT EXECUTED
 201351c:	02 80 00 06 	be  2013534 <fat_init_volume_info+0x1d0>       <== NOT EXECUTED
 2013520:	1f 00 00 04 	sethi  %hi(0x1000), %o7                        <== NOT EXECUTED
         (vol->bps != 2048) &&                                        
 2013524:	80 a0 80 0f 	cmp  %g2, %o7                                  <== NOT EXECUTED
 2013528:	02 80 00 04 	be  2013538 <fat_init_volume_info+0x1d4>       <== NOT EXECUTED
 201352c:	85 2a 60 10 	sll  %o1, 0x10, %g2                            <== NOT EXECUTED
 2013530:	30 80 00 d6 	b,a   2013888 <fat_init_volume_info+0x524>     <== 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;
 2013534:	85 2a 60 10 	sll  %o1, 0x10, %g2                            <== NOT EXECUTED
 2013538:	c0 2e e0 03 	clrb  [ %i3 + 3 ]                              
 201353c:	10 80 00 05 	b  2013550 <fat_init_volume_info+0x1ec>        
 2013540:	85 30 a0 19 	srl  %g2, 0x19, %g2                            
         i >>= 1, vol->sec_mul++);                                    
 2013544:	85 38 a0 01 	sra  %g2, 1, %g2                               <== NOT EXECUTED
 2013548:	9e 03 e0 01 	inc  %o7                                       <== NOT EXECUTED
 201354c:	de 2e e0 03 	stb  %o7, [ %i3 + 3 ]                          <== 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;
 2013550:	80 88 a0 01 	btst  1, %g2                                   
 2013554:	22 bf ff fc 	be,a   2013544 <fat_init_volume_info+0x1e0>    <== NEVER TAKEN
 2013558:	de 0e e0 03 	ldub  [ %i3 + 3 ], %o7                         <== NOT EXECUTED
         i >>= 1, vol->sec_mul++);                                    
    for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;               
 201355c:	93 2a 60 10 	sll  %o1, 0x10, %o1                            
 2013560:	c0 2e e0 02 	clrb  [ %i3 + 2 ]                              
 2013564:	93 32 60 10 	srl  %o1, 0x10, %o1                            
 2013568:	10 80 00 05 	b  201357c <fat_init_volume_info+0x218>        
 201356c:	9e 10 00 09 	mov  %o1, %o7                                  
         i >>= 1, vol->sec_log2++);                                   
 2013570:	84 00 a0 01 	inc  %g2                                       
 2013574:	9f 3b e0 01 	sra  %o7, 1, %o7                               
 2013578:	c4 2e e0 02 	stb  %g2, [ %i3 + 2 ]                          
        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;               
 201357c:	80 8b e0 01 	btst  1, %o7                                   
 2013580:	02 bf ff fc 	be  2013570 <fat_init_volume_info+0x20c>       
 2013584:	c4 0e e0 02 	ldub  [ %i3 + 2 ], %g2                         
         i >>= 1, vol->sec_log2++);                                   
                                                                      
    vol->bytes_per_block = vol->bps;                                  
 2013588:	c6 36 e0 0a 	sth  %g3, [ %i3 + 0xa ]                        
    vol->bytes_per_block_log2 = vol->sec_log2;                        
 201358c:	c4 2e e0 0c 	stb  %g2, [ %i3 + 0xc ]                        
    vol->sectors_per_block = 1;                                       
 2013590:	86 10 20 01 	mov  1, %g3                                    
                                                                      
    vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);              
 2013594:	fa 2e e0 04 	stb  %i5, [ %i3 + 4 ]                          
    /*                                                                
     * "sectors per cluster" of zero is invalid                       
     * (and would hang the following loop)                            
     */                                                               
    if (vol->spc == 0)                                                
 2013598:	9e 8f 60 ff 	andcc  %i5, 0xff, %o7                          
 201359c:	02 80 00 bb 	be  2013888 <fat_init_volume_info+0x524>       <== NEVER TAKEN
 20135a0:	c6 2e e0 09 	stb  %g3, [ %i3 + 9 ]                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
 20135a4:	10 80 00 05 	b  20135b8 <fat_init_volume_info+0x254>        
 20135a8:	c0 2e e0 05 	clrb  [ %i3 + 5 ]                              
         i >>= 1, vol->spc_log2++);                                   
 20135ac:	86 00 e0 01 	inc  %g3                                       
 20135b0:	9f 3b e0 01 	sra  %o7, 1, %o7                               
 20135b4:	c6 2e e0 05 	stb  %g3, [ %i3 + 5 ]                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;               
 20135b8:	80 8b e0 01 	btst  1, %o7                                   
 20135bc:	02 bf ff fc 	be  20135ac <fat_init_volume_info+0x248>       
 20135c0:	c6 0e e0 05 	ldub  [ %i3 + 5 ], %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)
 20135c4:	87 2a 40 03 	sll  %o1, %g3, %g3                             
 20135c8:	95 28 e0 10 	sll  %g3, 0x10, %o2                            
 20135cc:	1f 20 00 00 	sethi  %hi(0x80000000), %o7                    
 20135d0:	80 a2 80 0f 	cmp  %o2, %o7                                  
 20135d4:	18 80 00 ad 	bgu  2013888 <fat_init_volume_info+0x524>      <== NEVER TAKEN
 20135d8:	c6 36 e0 06 	sth  %g3, [ %i3 + 6 ]                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
 20135dc:	1f 00 00 3f 	sethi  %hi(0xfc00), %o7                        
 20135e0:	c0 2e e0 08 	clrb  [ %i3 + 8 ]                              
 20135e4:	9e 13 e3 ff 	or  %o7, 0x3ff, %o7                            
 20135e8:	10 80 00 05 	b  20135fc <fat_init_volume_info+0x298>        
 20135ec:	86 08 c0 0f 	and  %g3, %o7, %g3                             
         i >>= 1, vol->bpc_log2++);                                   
 20135f0:	87 38 e0 01 	sra  %g3, 1, %g3                               
 20135f4:	9e 03 e0 01 	inc  %o7                                       
 20135f8:	de 2e e0 08 	stb  %o7, [ %i3 + 8 ]                          
    {                                                                 
        close(vol->fd);                                               
        rtems_set_errno_and_return_minus_one(EINVAL);                 
    }                                                                 
                                                                      
    for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;               
 20135fc:	80 88 e0 01 	btst  1, %g3                                   
 2013600:	22 bf ff fc 	be,a   20135f0 <fat_init_volume_info+0x28c>    
 2013604:	de 0e e0 08 	ldub  [ %i3 + 8 ], %o7                         
         i >>= 1, vol->bpc_log2++);                                   
                                                                      
    vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);                         
 2013608:	f4 2e e0 0d 	stb  %i2, [ %i3 + 0xd ]                        
    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)) /
 201360c:	86 02 7f ff 	add  %o1, -1, %g3                              
                                                                      
    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);         
 2013610:	96 0a e0 ff 	and  %o3, 0xff, %o3                            
 2013614:	98 0b 20 ff 	and  %o4, 0xff, %o4                            
 2013618:	97 2a e0 08 	sll  %o3, 8, %o3                               
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
 201361c:	9a 0b 60 ff 	and  %o5, 0xff, %o5                            
                                                                      
    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);         
 2013620:	98 12 c0 0c 	or  %o3, %o4, %o4                              
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
 2013624:	9b 2b 60 08 	sll  %o5, 8, %o5                               
                                                                      
    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);         
 2013628:	d8 36 e0 18 	sth  %o4, [ %i3 + 0x18 ]                       
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
 201362c:	88 09 20 ff 	and  %g4, 0xff, %g4                            
 2013630:	88 13 40 04 	or  %o5, %g4, %g4                              
 2013634:	c8 36 e0 24 	sth  %g4, [ %i3 + 0x24 ]                       
                                                                      
    /* calculate the count of sectors occupied by the root directory */
    vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
 2013638:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 201363c:	c4 27 bf 80 	st  %g2, [ %fp + -128 ]                        
 2013640:	91 31 20 0b 	srl  %g4, 0xb, %o0                             
 2013644:	d8 27 bf 68 	st  %o4, [ %fp + -152 ]                        
 2013648:	7f ff bc 3e 	call  2002740 <.div>                           
 201364c:	90 02 00 03 	add  %o0, %g3, %o0                             
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
 2013650:	c4 07 bf 80 	ld  [ %fp + -128 ], %g2                        
    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)) /
 2013654:	d0 26 e0 28 	st  %o0, [ %i3 + 0x28 ]                        
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
 2013658:	85 2a 00 02 	sll  %o0, %g2, %g2                             
 201365c:	c4 26 e0 2c 	st  %g2, [ %i3 + 0x2c ]                        
                                                                      
    if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)                 
 2013660:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
 2013664:	ae 0d e0 ff 	and  %l7, 0xff, %l7                            
 2013668:	b1 2e 20 08 	sll  %i0, 8, %i0                               
    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)) /
 201366c:	86 10 00 08 	mov  %o0, %g3                                  
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
                                                                      
    if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)                 
 2013670:	ae 16 00 17 	or  %i0, %l7, %l7                              
 2013674:	af 2d e0 10 	sll  %l7, 0x10, %l7                            
 2013678:	80 a5 e0 00 	cmp  %l7, 0                                    
 201367c:	02 80 00 05 	be  2013690 <fat_init_volume_info+0x32c>       
 2013680:	d8 07 bf 68 	ld  [ %fp + -152 ], %o4                        
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);       
 2013684:	af 35 e0 10 	srl  %l7, 0x10, %l7                            
 2013688:	10 80 00 0c 	b  20136b8 <fat_init_volume_info+0x354>        
 201368c:	ee 26 e0 1c 	st  %l7, [ %i3 + 0x1c ]                        
    else                                                              
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);     
 2013690:	ac 0d a0 ff 	and  %l6, 0xff, %l6                            
 2013694:	aa 0d 60 ff 	and  %l5, 0xff, %l5                            
 2013698:	ad 2d a0 08 	sll  %l6, 8, %l6                               
 201369c:	ab 2d 60 10 	sll  %l5, 0x10, %l5                            
 20136a0:	a8 0d 20 ff 	and  %l4, 0xff, %l4                            
 20136a4:	aa 15 80 15 	or  %l6, %l5, %l5                              
 20136a8:	a7 2c e0 18 	sll  %l3, 0x18, %l3                            
 20136ac:	a8 15 40 14 	or  %l5, %l4, %l4                              
 20136b0:	a6 15 00 13 	or  %l4, %l3, %l3                              
 20136b4:	e6 26 e0 1c 	st  %l3, [ %i3 + 0x1c ]                        
                                                                      
    vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +     
 20136b8:	d2 06 e0 1c 	ld  [ %i3 + 0x1c ], %o1                        
 20136bc:	99 2b 20 10 	sll  %o4, 0x10, %o4                            
 20136c0:	c6 27 bf 84 	st  %g3, [ %fp + -124 ]                        
 20136c4:	b1 33 20 10 	srl  %o4, 0x10, %i0                            
 20136c8:	7f ff bb e2 	call  2002650 <.umul>                          
 20136cc:	90 0e a0 ff 	and  %i2, 0xff, %o0                            
 20136d0:	c6 07 bf 84 	ld  [ %fp + -124 ], %g3                        
 20136d4:	90 06 00 08 	add  %i0, %o0, %o0                             
 20136d8:	86 00 c0 08 	add  %g3, %o0, %g3                             
                     vol->rdir_secs;                                  
                                                                      
    /* for  FAT12/16 root dir starts at(sector) */                    
    vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;       
 20136dc:	d0 26 e0 20 	st  %o0, [ %i3 + 0x20 ]                        
                                                                      
    if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)             
 20136e0:	a4 0c a0 ff 	and  %l2, 0xff, %l2                            
 20136e4:	a2 0c 60 ff 	and  %l1, 0xff, %l1                            
 20136e8:	a5 2c a0 08 	sll  %l2, 8, %l2                               
 20136ec:	a2 14 80 11 	or  %l2, %l1, %l1                              
 20136f0:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
 20136f4:	80 a4 60 00 	cmp  %l1, 0                                    
 20136f8:	02 80 00 05 	be  201370c <fat_init_volume_info+0x3a8>       
 20136fc:	c6 26 e0 34 	st  %g3, [ %i3 + 0x34 ]                        
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);     
 2013700:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
 2013704:	10 80 00 0d 	b  2013738 <fat_init_volume_info+0x3d4>        
 2013708:	e2 26 e0 30 	st  %l1, [ %i3 + 0x30 ]                        
    else                                                              
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);     
 201370c:	f4 0f bf 9a 	ldub  [ %fp + -102 ], %i2                      
 2013710:	c2 0f bf 8f 	ldub  [ %fp + -113 ], %g1                      
 2013714:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
 2013718:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
 201371c:	a1 2c 20 08 	sll  %l0, 8, %l0                               
 2013720:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
 2013724:	85 28 60 18 	sll  %g1, 0x18, %g2                            
 2013728:	b2 14 00 19 	or  %l0, %i1, %i1                              
 201372c:	b4 16 40 1a 	or  %i1, %i2, %i2                              
 2013730:	b4 16 80 02 	or  %i2, %g2, %i2                              
 2013734:	f4 26 e0 30 	st  %i2, [ %i3 + 0x30 ]                        
                                                                      
    data_secs = vol->tot_secs - vol->data_fsec;                       
 2013738:	d0 06 e0 30 	ld  [ %i3 + 0x30 ], %o0                        
                                                                      
    vol->data_cls = data_secs / vol->spc;                             
 201373c:	92 0f 60 ff 	and  %i5, 0xff, %o1                            
 2013740:	7f ff bb fe 	call  2002738 <.udiv>                          
 2013744:	90 22 00 03 	sub  %o0, %g3, %o0                             
                                                                      
    /* determine FAT type at least */                                 
    if ( vol->data_cls < FAT_FAT12_MAX_CLN)                           
 2013748:	80 a2 2f f4 	cmp  %o0, 0xff4                                
 201374c:	18 80 00 08 	bgu  201376c <fat_init_volume_info+0x408>      
 2013750:	d0 26 e0 38 	st  %o0, [ %i3 + 0x38 ]                        
    {                                                                 
        vol->type = FAT_FAT12;                                        
 2013754:	84 10 20 01 	mov  1, %g2                                    
 2013758:	c4 2e e0 0e 	stb  %g2, [ %i3 + 0xe ]                        
        vol->mask = FAT_FAT12_MASK;                                   
 201375c:	84 10 2f ff 	mov  0xfff, %g2                                
 2013760:	c4 26 e0 10 	st  %g2, [ %i3 + 0x10 ]                        
        vol->eoc_val = FAT_FAT12_EOC;                                 
 2013764:	10 80 00 0f 	b  20137a0 <fat_init_volume_info+0x43c>        
 2013768:	84 10 2f f8 	mov  0xff8, %g2                                
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
 201376c:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
 2013770:	86 10 a3 f4 	or  %g2, 0x3f4, %g3	! fff4 <PROM_START+0xfff4> 
 2013774:	80 a2 00 03 	cmp  %o0, %g3                                  
 2013778:	38 80 00 05 	bgu,a   201378c <fat_init_volume_info+0x428>   
 201377c:	84 10 20 04 	mov  4, %g2                                    
        {                                                             
            vol->type = FAT_FAT16;                                    
 2013780:	86 10 20 02 	mov  2, %g3                                    
 2013784:	10 80 00 04 	b  2013794 <fat_init_volume_info+0x430>        
 2013788:	c6 2e e0 0e 	stb  %g3, [ %i3 + 0xe ]                        
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
 201378c:	c4 2e e0 0e 	stb  %g2, [ %i3 + 0xe ]                        
            vol->mask = FAT_FAT32_MASK;                               
 2013790:	05 03 ff ff 	sethi  %hi(0xffffc00), %g2                     
 2013794:	86 10 a3 ff 	or  %g2, 0x3ff, %g3	! fffffff <RAM_END+0xdbfffff>
            vol->eoc_val = FAT_FAT32_EOC;                             
 2013798:	84 10 a3 f8 	or  %g2, 0x3f8, %g2                            
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
 201379c:	c6 26 e0 10 	st  %g3, [ %i3 + 0x10 ]                        
            vol->eoc_val = FAT_FAT32_EOC;                             
 20137a0:	c4 26 e0 14 	st  %g2, [ %i3 + 0x14 ]                        
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
 20137a4:	c4 0e e0 0e 	ldub  [ %i3 + 0xe ], %g2                       
 20137a8:	80 a0 a0 04 	cmp  %g2, 4                                    
 20137ac:	12 80 00 63 	bne  2013938 <fat_init_volume_info+0x5d4>      
 20137b0:	82 10 3f ff 	mov  -1, %g1                                   
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
 20137b4:	c6 0f bf 9c 	ldub  [ %fp + -100 ], %g3                      
 20137b8:	c4 0f bf 9b 	ldub  [ %fp + -101 ], %g2                      
 20137bc:	87 28 e0 08 	sll  %g3, 8, %g3                               
 20137c0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20137c4:	c2 0f bf 97 	ldub  [ %fp + -105 ], %g1                      
 20137c8:	84 10 c0 02 	or  %g3, %g2, %g2                              
 20137cc:	c6 0f bf 9d 	ldub  [ %fp + -99 ], %g3                       
 20137d0:	84 10 80 03 	or  %g2, %g3, %g2                              
 20137d4:	87 28 60 18 	sll  %g1, 0x18, %g3                            
 20137d8:	84 10 80 03 	or  %g2, %g3, %g2                              
 20137dc:	c4 26 e0 3c 	st  %g2, [ %i3 + 0x3c ]                        
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
 20137e0:	84 0f 3f 80 	and  %i4, -128, %g2                            
        if (vol->mirror)                                              
 20137e4:	80 88 a0 80 	btst  0x80, %g2                                
 20137e8:	02 80 00 05 	be  20137fc <fat_init_volume_info+0x498>       <== ALWAYS TAKEN
 20137ec:	c4 2e e0 54 	stb  %g2, [ %i3 + 0x54 ]                       
            vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
 20137f0:	b8 0f 20 0f 	and  %i4, 0xf, %i4                             <== NOT EXECUTED
 20137f4:	10 80 00 03 	b  2013800 <fat_init_volume_info+0x49c>        <== NOT EXECUTED
 20137f8:	f8 2e e0 5c 	stb  %i4, [ %i3 + 0x5c ]                       <== NOT EXECUTED
        else                                                          
            vol->afat = 0;                                            
 20137fc:	c0 2e e0 5c 	clrb  [ %i3 + 0x5c ]                           
                                                                      
        vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);    
 2013800:	d2 0f bf 9e 	ldub  [ %fp + -98 ], %o1                       
 2013804:	c4 0f bf 9f 	ldub  [ %fp + -97 ], %g2                       
 2013808:	93 2a 60 08 	sll  %o1, 8, %o1                               
 201380c:	92 12 40 02 	or  %o1, %g2, %o1                              
 2013810:	d2 36 e0 40 	sth  %o1, [ %i3 + 0x40 ]                       
        if( vol->info_sec == 0 )                                      
 2013814:	93 2a 60 10 	sll  %o1, 0x10, %o1                            
 2013818:	93 32 60 10 	srl  %o1, 0x10, %o1                            
 201381c:	80 a2 60 00 	cmp  %o1, 0                                    
 2013820:	32 80 00 03 	bne,a   201382c <fat_init_volume_info+0x4c8>   <== ALWAYS TAKEN
 2013824:	90 10 00 1b 	mov  %i3, %o0                                  
 2013828:	30 80 00 18 	b,a   2013888 <fat_init_volume_info+0x524>     <== NOT EXECUTED
            close(vol->fd);                                           
            rtems_set_errno_and_return_minus_one( EINVAL );           
        }                                                             
        else                                                          
        {                                                             
            ret = _fat_block_read(fs_info, vol->info_sec , 0,         
 201382c:	94 10 20 00 	clr  %o2                                       
 2013830:	96 10 20 04 	mov  4, %o3                                    
 2013834:	7f ff fd f3 	call  2013000 <_fat_block_read>                
 2013838:	98 07 bf a8 	add  %fp, -88, %o4                             
                                  FAT_FSI_LEADSIG_SIZE, fs_info_sector);
            if ( ret < 0 )                                            
 201383c:	80 a2 20 00 	cmp  %o0, 0                                    
 2013840:	06 80 00 22 	bl  20138c8 <fat_init_volume_info+0x564>       <== NEVER TAKEN
 2013844:	c4 0f bf aa 	ldub  [ %fp + -86 ], %g2                       
            {                                                         
                close(vol->fd);                                       
                return -1;                                            
            }                                                         
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
 2013848:	c6 0f bf a9 	ldub  [ %fp + -87 ], %g3                       
 201384c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2013850:	87 28 e0 08 	sll  %g3, 8, %g3                               
 2013854:	86 10 c0 02 	or  %g3, %g2, %g3                              
 2013858:	c4 0f bf a8 	ldub  [ %fp + -88 ], %g2                       
 201385c:	86 10 c0 02 	or  %g3, %g2, %g3                              
 2013860:	c4 0f bf ab 	ldub  [ %fp + -85 ], %g2                       
 2013864:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 2013868:	86 10 c0 02 	or  %g3, %g2, %g3                              
 201386c:	05 10 58 54 	sethi  %hi(0x41615000), %g2                    
 2013870:	84 10 a2 52 	or  %g2, 0x252, %g2	! 41615252 <RAM_END+0x3f215252>
 2013874:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2013878:	02 80 00 0a 	be  20138a0 <fat_init_volume_info+0x53c>       <== ALWAYS TAKEN
 201387c:	90 10 00 1b 	mov  %i3, %o0                                  
 *     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);                                  
 2013880:	7f ff fd 3d 	call  2012d74 <fat_buf_release>                <== NOT EXECUTED
 2013884:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
                FAT_FSINFO_LEAD_SIGNATURE_VALUE)                      
            {                                                         
                _fat_block_release(fs_info);                          
                close(vol->fd);                                       
 2013888:	7f ff c5 f6 	call  2005060 <close>                          <== NOT EXECUTED
 201388c:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EINVAL );       
 2013890:	40 00 1f 47 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2013894:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2013898:	10 80 00 82 	b  2013aa0 <fat_init_volume_info+0x73c>        <== NOT EXECUTED
 201389c:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
            }                                                         
            else                                                      
            {                                                         
                ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
 20138a0:	d2 16 e0 40 	lduh  [ %i3 + 0x40 ], %o1                      
 20138a4:	94 10 21 e4 	mov  0x1e4, %o2                                
 20138a8:	96 10 20 0c 	mov  0xc, %o3                                  
 20138ac:	7f ff fd d5 	call  2013000 <_fat_block_read>                
 20138b0:	98 07 bf a8 	add  %fp, -88, %o4                             
                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
                if ( ret < 0 )                                        
 20138b4:	80 a2 20 00 	cmp  %o0, 0                                    
 20138b8:	16 80 00 08 	bge  20138d8 <fat_init_volume_info+0x574>      <== ALWAYS TAKEN
 20138bc:	c6 0f bf ad 	ldub  [ %fp + -83 ], %g3                       
 *     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);                                  
 20138c0:	7f ff fd 2d 	call  2012d74 <fat_buf_release>                <== NOT EXECUTED
 20138c4:	90 10 00 1b 	mov  %i3, %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);                                   
 20138c8:	7f ff c5 e6 	call  2005060 <close>                          <== NOT EXECUTED
 20138cc:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
    {                                                                 
        close(vol->fd);                                               
        free(fs_info->vhash);                                         
        free(fs_info->rhash);                                         
        free(fs_info->uino);                                          
        rtems_set_errno_and_return_minus_one( ENOMEM );               
 20138d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20138d4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
 20138d8:	c4 0f bf ae 	ldub  [ %fp + -82 ], %g2                       
 20138dc:	87 28 e0 08 	sll  %g3, 8, %g3                               
 20138e0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20138e4:	84 10 c0 02 	or  %g3, %g2, %g2                              
 20138e8:	c6 0f bf ac 	ldub  [ %fp + -84 ], %g3                       
 20138ec:	84 10 80 03 	or  %g2, %g3, %g2                              
 20138f0:	c6 0f bf af 	ldub  [ %fp + -81 ], %g3                       
 20138f4:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 20138f8:	84 10 80 03 	or  %g2, %g3, %g2                              
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
 20138fc:	c6 0f bf b1 	ldub  [ %fp + -79 ], %g3                       
                    _fat_block_release(fs_info);                      
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
 2013900:	c4 26 e0 48 	st  %g2, [ %i3 + 0x48 ]                        
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
                vol->free_cls = vol->free_cls_in_fs_info;             
 2013904:	c4 26 e0 44 	st  %g2, [ %i3 + 0x44 ]                        
                vol->next_cl_in_fs_info =                             
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
 2013908:	c4 0f bf b2 	ldub  [ %fp + -78 ], %g2                       
 201390c:	87 28 e0 08 	sll  %g3, 8, %g3                               
 2013910:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2013914:	84 10 c0 02 	or  %g3, %g2, %g2                              
 2013918:	c6 0f bf b0 	ldub  [ %fp + -80 ], %g3                       
 201391c:	84 10 80 03 	or  %g2, %g3, %g2                              
 2013920:	c6 0f bf b3 	ldub  [ %fp + -77 ], %g3                       
 2013924:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 2013928:	84 10 80 03 	or  %g2, %g3, %g2                              
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
                  FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);  
                vol->free_cls = vol->free_cls_in_fs_info;             
                vol->next_cl_in_fs_info =                             
 201392c:	c4 26 e0 50 	st  %g2, [ %i3 + 0x50 ]                        
                  FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);   
                vol->next_cl = vol->next_cl_in_fs_info;               
 2013930:	10 80 00 07 	b  201394c <fat_init_volume_info+0x5e8>        
 2013934:	c4 26 e0 4c 	st  %g2, [ %i3 + 0x4c ]                        
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
 2013938:	c0 26 e0 3c 	clr  [ %i3 + 0x3c ]                            
        vol->mirror = 0;                                              
 201393c:	c0 2e e0 54 	clrb  [ %i3 + 0x54 ]                           
        vol->afat = 0;                                                
 2013940:	c0 2e e0 5c 	clrb  [ %i3 + 0x5c ]                           
        vol->free_cls = FAT_UNDEFINED_VALUE;                          
 2013944:	c2 26 e0 44 	st  %g1, [ %i3 + 0x44 ]                        
        vol->next_cl = FAT_UNDEFINED_VALUE;                           
 2013948:	c2 26 e0 4c 	st  %g1, [ %i3 + 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);                                  
 201394c:	7f ff fd 0a 	call  2012d74 <fat_buf_release>                
 2013950:	90 10 00 1b 	mov  %i3, %o0                                  
        vol->next_cl = FAT_UNDEFINED_VALUE;                           
    }                                                                 
                                                                      
    _fat_block_release(fs_info);                                      
                                                                      
    vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;       
 2013954:	d2 06 e0 1c 	ld  [ %i3 + 0x1c ], %o1                        
 2013958:	7f ff bb 3e 	call  2002650 <.umul>                          
 201395c:	d0 0e e0 5c 	ldub  [ %i3 + 0x5c ], %o0                      
 2013960:	c4 16 e0 18 	lduh  [ %i3 + 0x18 ], %g2                      
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
 2013964:	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;       
 2013968:	90 02 00 02 	add  %o0, %g2, %o0                             
 201396c:	d0 26 e0 58 	st  %o0, [ %i3 + 0x58 ]                        
                                                                      
    /* set up collection of fat-files fd */                           
    fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
 2013970:	7f ff c5 a5 	call  2005004 <calloc>                         
 2013974:	90 10 20 02 	mov  2, %o0                                    
    if ( fs_info->vhash == NULL )                                     
 2013978:	80 a2 20 00 	cmp  %o0, 0                                    
 201397c:	02 80 00 12 	be  20139c4 <fat_init_volume_info+0x660>       <== NEVER TAKEN
 2013980:	d0 26 e0 6c 	st  %o0, [ %i3 + 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 );                        
 2013984:	84 02 20 04 	add  %o0, 4, %g2                               
 2013988:	86 02 20 10 	add  %o0, 0x10, %g3                            
                                                                      
  head->next = tail;                                                  
 201398c:	c4 22 00 00 	st  %g2, [ %o0 ]                               
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 );                        
 2013990:	84 02 20 0c 	add  %o0, 0xc, %g2                             
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
 2013994:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
  tail->previous = head;                                              
 2013998:	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;                                                  
 201399c:	c6 22 20 0c 	st  %g3, [ %o0 + 0xc ]                         
  head->previous = NULL;                                              
 20139a0:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
  tail->previous = head;                                              
 20139a4:	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));
 20139a8:	92 10 20 0c 	mov  0xc, %o1                                  
 20139ac:	7f ff c5 96 	call  2005004 <calloc>                         
 20139b0:	90 10 20 02 	mov  2, %o0                                    
    if ( fs_info->rhash == NULL )                                     
 20139b4:	80 a2 20 00 	cmp  %o0, 0                                    
 20139b8:	12 80 00 06 	bne  20139d0 <fat_init_volume_info+0x66c>      <== ALWAYS TAKEN
 20139bc:	d0 26 e0 70 	st  %o0, [ %i3 + 0x70 ]                        
 20139c0:	30 80 00 1c 	b,a   2013a30 <fat_init_volume_info+0x6cc>     <== 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);                                               
 20139c4:	7f ff c5 a7 	call  2005060 <close>                          <== NOT EXECUTED
 20139c8:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
 20139cc:	30 80 00 32 	b,a   2013a94 <fat_init_volume_info+0x730>     <== 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 );                        
 20139d0:	84 02 20 04 	add  %o0, 4, %g2                               
                                                                      
  head->next = tail;                                                  
 20139d4:	c4 22 00 00 	st  %g2, [ %o0 ]                               
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 );                        
 20139d8:	84 02 20 0c 	add  %o0, 0xc, %g2                             
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
 20139dc:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
  tail->previous = head;                                              
 20139e0:	c4 22 20 14 	st  %g2, [ %o0 + 0x14 ]                        
 20139e4:	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;                                              
 20139e8:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
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 );                        
 20139ec:	86 02 20 10 	add  %o0, 0x10, %g3                            
        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;                
 20139f0:	84 10 21 00 	mov  0x100, %g2                                
                                                                      
  head->next = tail;                                                  
 20139f4:	c6 22 20 0c 	st  %g3, [ %o0 + 0xc ]                         
 20139f8:	c4 26 e0 7c 	st  %g2, [ %i3 + 0x7c ]                        
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
 20139fc:	c6 06 e0 30 	ld  [ %i3 + 0x30 ], %g3                        
 2013a00:	c4 0e e0 03 	ldub  [ %i3 + 3 ], %g2                         
    fs_info->index = 0;                                               
 2013a04:	c0 26 e0 78 	clr  [ %i3 + 0x78 ]                            
    }                                                                 
    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;        
 2013a08:	85 28 c0 02 	sll  %g3, %g2, %g2                             
 2013a0c:	85 28 a0 04 	sll  %g2, 4, %g2                               
    fs_info->index = 0;                                               
    fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
 2013a10:	90 10 21 00 	mov  0x100, %o0                                
    }                                                                 
    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;        
 2013a14:	c4 26 e0 80 	st  %g2, [ %i3 + 0x80 ]                        
    fs_info->index = 0;                                               
    fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
 2013a18:	7f ff c5 7b 	call  2005004 <calloc>                         
 2013a1c:	92 10 20 01 	mov  1, %o1                                    
    if ( fs_info->uino == NULL )                                      
 2013a20:	80 a2 20 00 	cmp  %o0, 0                                    
 2013a24:	12 80 00 0d 	bne  2013a58 <fat_init_volume_info+0x6f4>      <== ALWAYS TAKEN
 2013a28:	d0 26 e0 74 	st  %o0, [ %i3 + 0x74 ]                        
 2013a2c:	30 80 00 05 	b,a   2013a40 <fat_init_volume_info+0x6dc>     <== 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);                                               
 2013a30:	7f ff c5 8c 	call  2005060 <close>                          <== NOT EXECUTED
 2013a34:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
 2013a38:	10 80 00 15 	b  2013a8c <fat_init_volume_info+0x728>        <== NOT EXECUTED
 2013a3c:	d0 06 e0 6c 	ld  [ %i3 + 0x6c ], %o0                        <== 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);                                               
 2013a40:	7f ff c5 88 	call  2005060 <close>                          <== NOT EXECUTED
 2013a44:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
 2013a48:	7f ff c6 43 	call  2005354 <free>                           <== NOT EXECUTED
 2013a4c:	d0 06 e0 6c 	ld  [ %i3 + 0x6c ], %o0                        <== NOT EXECUTED
        free(fs_info->rhash);                                         
 2013a50:	10 80 00 0f 	b  2013a8c <fat_init_volume_info+0x728>        <== NOT EXECUTED
 2013a54:	d0 06 e0 70 	ld  [ %i3 + 0x70 ], %o0                        <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
    }                                                                 
    fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));  
 2013a58:	d0 16 c0 00 	lduh  [ %i3 ], %o0                             
 2013a5c:	7f ff c5 6a 	call  2005004 <calloc>                         
 2013a60:	92 10 20 01 	mov  1, %o1                                    
    if (fs_info->sec_buf == NULL)                                     
 2013a64:	80 a2 20 00 	cmp  %o0, 0                                    
 2013a68:	12 80 00 11 	bne  2013aac <fat_init_volume_info+0x748>      <== ALWAYS TAKEN
 2013a6c:	d0 26 e0 90 	st  %o0, [ %i3 + 0x90 ]                        
    {                                                                 
        close(vol->fd);                                               
 2013a70:	7f ff c5 7c 	call  2005060 <close>                          <== NOT EXECUTED
 2013a74:	d0 06 e0 60 	ld  [ %i3 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
 2013a78:	7f ff c6 37 	call  2005354 <free>                           <== NOT EXECUTED
 2013a7c:	d0 06 e0 6c 	ld  [ %i3 + 0x6c ], %o0                        <== NOT EXECUTED
        free(fs_info->rhash);                                         
 2013a80:	7f ff c6 35 	call  2005354 <free>                           <== NOT EXECUTED
 2013a84:	d0 06 e0 70 	ld  [ %i3 + 0x70 ], %o0                        <== NOT EXECUTED
        free(fs_info->uino);                                          
 2013a88:	d0 06 e0 74 	ld  [ %i3 + 0x74 ], %o0                        <== NOT EXECUTED
 2013a8c:	7f ff c6 32 	call  2005354 <free>                           <== NOT EXECUTED
 2013a90:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
 2013a94:	40 00 1e c6 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2013a98:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2013a9c:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
 2013aa0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2013aa4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013aa8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
      return bytes_written;                                           
}                                                                     
                                                                      
static bool is_cluster_aligned(const fat_vol_t *vol, uint32_t sec_num)
{                                                                     
    return (sec_num & (vol->spc - 1)) == 0;                           
 2013aac:	c4 0e e0 04 	ldub  [ %i3 + 4 ], %g2                         
 2013ab0:	c6 06 e0 34 	ld  [ %i3 + 0x34 ], %g3                        
 2013ab4:	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)                       
 2013ab8:	80 88 80 03 	btst  %g2, %g3                                 
 2013abc:	22 80 00 04 	be,a   2013acc <fat_init_volume_info+0x768>    <== ALWAYS TAKEN
 2013ac0:	c6 0e e0 0e 	ldub  [ %i3 + 0xe ], %g3                       
            vol->bytes_per_block_log2 = vol->bpc_log2;                
            vol->sectors_per_block = vol->spc;                        
        }                                                             
    }                                                                 
                                                                      
    return RC_OK;                                                     
 2013ac4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013ac8:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
     * 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)))
 2013acc:	80 a0 e0 04 	cmp  %g3, 4                                    
 2013ad0:	22 80 00 07 	be,a   2013aec <fat_init_volume_info+0x788>    
 2013ad4:	d0 06 e0 64 	ld  [ %i3 + 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;                           
 2013ad8:	c6 06 e0 20 	ld  [ %i3 + 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)))
 2013adc:	80 88 80 03 	btst  %g2, %g3                                 
 2013ae0:	12 80 00 0f 	bne  2013b1c <fat_init_volume_info+0x7b8>      <== NEVER TAKEN
 2013ae4:	b0 10 20 00 	clr  %i0                                       
    {                                                                 
        sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);    
 2013ae8:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        
 2013aec:	d2 16 e0 06 	lduh  [ %i3 + 6 ], %o1                         
 2013af0:	7f ff f6 78 	call  20114d0 <rtems_bdbuf_set_block_size>     
 2013af4:	94 10 20 01 	mov  1, %o2                                    
        if (sc == RTEMS_SUCCESSFUL)                                   
 2013af8:	80 a2 20 00 	cmp  %o0, 0                                    
 2013afc:	12 80 00 08 	bne  2013b1c <fat_init_volume_info+0x7b8>      <== NEVER TAKEN
 2013b00:	b0 10 20 00 	clr  %i0                                       
        {                                                             
            vol->bytes_per_block = vol->bpc;                          
 2013b04:	c4 16 e0 06 	lduh  [ %i3 + 6 ], %g2                         
 2013b08:	c4 36 e0 0a 	sth  %g2, [ %i3 + 0xa ]                        
            vol->bytes_per_block_log2 = vol->bpc_log2;                
 2013b0c:	c4 0e e0 08 	ldub  [ %i3 + 8 ], %g2                         
 2013b10:	c4 2e e0 0c 	stb  %g2, [ %i3 + 0xc ]                        
            vol->sectors_per_block = vol->spc;                        
 2013b14:	c4 0e e0 04 	ldub  [ %i3 + 4 ], %g2                         
 2013b18:	c4 2e e0 09 	stb  %g2, [ %i3 + 9 ]                          
        }                                                             
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
 2013b1c:	81 c7 e0 08 	ret                                            
 2013b20:	81 e8 00 00 	restore                                        
                                                                      

02019a74 <fat_scan_fat_for_free_clusters>: uint32_t count, uint32_t *cls_added, uint32_t *last_cl, bool zero_fill ) {
 2019a74:	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;          
 2019a78:	e8 06 20 38 	ld  [ %i0 + 0x38 ], %l4                        
    bool                                  zero_fill                   
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
 2019a7c:	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;                                                   
 2019a80:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
    if (count == 0)                                                   
 2019a84:	80 a6 a0 00 	cmp  %i2, 0                                    
 2019a88:	02 80 00 7e 	be  2019c80 <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
 2019a8c:	a2 10 20 00 	clr  %l1                                       
        return rc;                                                    
                                                                      
    if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)                  
 2019a90:	e0 06 20 4c 	ld  [ %i0 + 0x4c ], %l0                        
 2019a94:	80 a4 3f ff 	cmp  %l0, -1                                   
 2019a98:	22 80 00 02 	be,a   2019aa0 <fat_scan_fat_for_free_clusters+0x2c>
 2019a9c:	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;          
 2019aa0:	a8 05 20 02 	add  %l4, 2, %l4                               
 2019aa4:	a6 10 20 02 	mov  2, %l3                                    
 2019aa8:	10 80 00 5a 	b  2019c10 <fat_scan_fat_for_free_clusters+0x19c>
 2019aac:	a4 10 20 00 	clr  %l2                                       
     * starting at cluster 2, so the maximum valid cluster number is  
     * (fs_info->vol.data_cls + 1)                                    
     */                                                               
    while (i < data_cls_val)                                          
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);        
 2019ab0:	92 10 00 10 	mov  %l0, %o1                                  
 2019ab4:	7f ff fe ae 	call  201956c <fat_get_fat_cluster>            
 2019ab8:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
 2019abc:	a2 92 20 00 	orcc  %o0, 0, %l1                              
 2019ac0:	02 80 00 0b 	be  2019aec <fat_scan_fat_for_free_clusters+0x78><== ALWAYS TAKEN
 2019ac4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        {                                                             
            if (*cls_added != 0)                                      
 2019ac8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               <== NOT EXECUTED
 2019acc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2019ad0:	22 80 00 6d 	be,a   2019c84 <fat_scan_fat_for_free_clusters+0x210><== NOT EXECUTED
 2019ad4:	b0 10 00 11 	mov  %l1, %i0                                  <== NOT EXECUTED
                fat_free_fat_clusters_chain(fs_info, (*chain));       
 2019ad8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 2019adc:	7f ff ff b7 	call  20199b8 <fat_free_fat_clusters_chain>    <== NOT EXECUTED
 2019ae0:	90 10 00 18 	mov  %i0, %o0                                  <== 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;                                                        
}                                                                     
 2019ae4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019ae8:	91 e8 00 11 	restore  %g0, %l1, %o0                         <== NOT EXECUTED
            if (*cls_added != 0)                                      
                fat_free_fat_clusters_chain(fs_info, (*chain));       
            return rc;                                                
        }                                                             
                                                                      
        if (next_cln == FAT_GENFAT_FREE)                              
 2019aec:	80 a0 60 00 	cmp  %g1, 0                                    
 2019af0:	32 80 00 44 	bne,a   2019c00 <fat_scan_fat_for_free_clusters+0x18c>
 2019af4:	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)                                      
 2019af8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 2019afc:	80 a0 60 00 	cmp  %g1, 0                                    
 2019b00:	12 80 00 0e 	bne  2019b38 <fat_scan_fat_for_free_clusters+0xc4>
 2019b04:	90 10 00 18 	mov  %i0, %o0                                  
            {                                                         
                *chain = cl4find;                                     
 2019b08:	e0 26 40 00 	st  %l0, [ %i1 ]                               
                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
 2019b0c:	92 10 00 10 	mov  %l0, %o1                                  
 2019b10:	7f ff ff 09 	call  2019734 <fat_set_fat_cluster>            
 2019b14:	94 10 3f ff 	mov  -1, %o2                                   
                if ( rc != RC_OK )                                    
 2019b18:	80 a2 20 00 	cmp  %o0, 0                                    
 2019b1c:	32 80 00 59 	bne,a   2019c80 <fat_scan_fat_for_free_clusters+0x20c><== NEVER TAKEN
 2019b20:	a2 10 00 08 	mov  %o0, %l1                                  <== NOT EXECUTED
                rc = fat_set_fat_cluster(fs_info, save_cln, cl4find); 
                if ( rc != RC_OK )                                    
                    goto cleanup;                                     
            }                                                         
                                                                      
            if (zero_fill)                                            
 2019b24:	80 a7 60 00 	cmp  %i5, 0                                    
 2019b28:	22 80 00 18 	be,a   2019b88 <fat_scan_fat_for_free_clusters+0x114>
 2019b2c:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
            {                                                         
                bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
 2019b30:	10 80 00 1c 	b  2019ba0 <fat_scan_fat_for_free_clusters+0x12c>
 2019b34:	d6 16 20 06 	lduh  [ %i0 + 6 ], %o3                         
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                /* set EOC value to new allocated cluster */          
                rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
 2019b38:	92 10 00 10 	mov  %l0, %o1                                  
 2019b3c:	7f ff fe fe 	call  2019734 <fat_set_fat_cluster>            
 2019b40:	94 10 3f ff 	mov  -1, %o2                                   
 2019b44:	aa 10 00 08 	mov  %o0, %l5                                  
                if ( rc != RC_OK )                                    
 2019b48:	80 a5 60 00 	cmp  %l5, 0                                    
 2019b4c:	02 80 00 07 	be  2019b68 <fat_scan_fat_for_free_clusters+0xf4><== ALWAYS TAKEN
 2019b50:	90 10 00 18 	mov  %i0, %o0                                  
                {                                                     
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(fs_info, (*chain));   
 2019b54:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 2019b58:	7f ff ff 98 	call  20199b8 <fat_free_fat_clusters_chain>    <== NOT EXECUTED
 2019b5c:	a2 10 00 15 	mov  %l5, %l1                                  <== 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;                                                        
}                                                                     
 2019b60:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019b64:	91 e8 00 11 	restore  %g0, %l1, %o0                         <== NOT EXECUTED
                    /* cleanup activity */                            
                    fat_free_fat_clusters_chain(fs_info, (*chain));   
                    return rc;                                        
                }                                                     
                                                                      
                rc = fat_set_fat_cluster(fs_info, save_cln, cl4find); 
 2019b68:	92 10 00 12 	mov  %l2, %o1                                  
 2019b6c:	7f ff fe f2 	call  2019734 <fat_set_fat_cluster>            
 2019b70:	94 10 00 10 	mov  %l0, %o2                                  
                if ( rc != RC_OK )                                    
 2019b74:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 2019b78:	02 bf ff ec 	be  2019b28 <fat_scan_fat_for_free_clusters+0xb4><== ALWAYS TAKEN
 2019b7c:	80 a7 60 00 	cmp  %i5, 0                                    
    return RC_OK;                                                     
                                                                      
cleanup:                                                              
                                                                      
    /* cleanup activity */                                            
    fat_free_fat_clusters_chain(fs_info, (*chain));                   
 2019b80:	10 80 00 35 	b  2019c54 <fat_scan_fat_for_free_clusters+0x1e0><== NOT EXECUTED
 2019b84:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
                    goto cleanup;                                     
                }                                                     
            }                                                         
                                                                      
            save_cln = cl4find;                                       
            (*cls_added)++;                                           
 2019b88:	82 00 60 01 	inc  %g1                                       
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
 2019b8c:	80 a0 40 1a 	cmp  %g1, %i2                                  
 2019b90:	02 80 00 0f 	be  2019bcc <fat_scan_fat_for_free_clusters+0x158>
 2019b94:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
 2019b98:	10 80 00 19 	b  2019bfc <fat_scan_fat_for_free_clusters+0x188>
 2019b9c:	a4 10 00 10 	mov  %l0, %l2                                  
                    goto cleanup;                                     
            }                                                         
                                                                      
            if (zero_fill)                                            
            {                                                         
                bytes_written = fat_cluster_set (fs_info, cl4find, 0, fs_info->vol.bpc, 0);
 2019ba0:	90 10 00 18 	mov  %i0, %o0                                  
 2019ba4:	92 10 00 10 	mov  %l0, %o1                                  
 2019ba8:	94 10 20 00 	clr  %o2                                       
 2019bac:	7f ff e5 5b 	call  2013118 <fat_cluster_set>                
 2019bb0:	98 10 20 00 	clr  %o4                                       
                if (fs_info->vol.bpc != bytes_written)                
 2019bb4:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
 2019bb8:	80 a0 40 08 	cmp  %g1, %o0                                  
 2019bbc:	22 bf ff f3 	be,a   2019b88 <fat_scan_fat_for_free_clusters+0x114><== ALWAYS TAKEN
 2019bc0:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
                {                                                     
                    rc = -1;                                          
 2019bc4:	10 80 00 23 	b  2019c50 <fat_scan_fat_for_free_clusters+0x1dc><== NOT EXECUTED
 2019bc8:	a4 10 3f ff 	mov  -1, %l2                                   <== 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) 
 2019bcc:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
 2019bd0:	80 a0 7f ff 	cmp  %g1, -1                                   
 2019bd4:	02 80 00 05 	be  2019be8 <fat_scan_fat_for_free_clusters+0x174><== ALWAYS TAKEN
 2019bd8:	e0 26 20 4c 	st  %l0, [ %i0 + 0x4c ]                        
                        fs_info->vol.free_cls -= (*cls_added);        
 2019bdc:	c4 06 c0 00 	ld  [ %i3 ], %g2                               <== NOT EXECUTED
 2019be0:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
 2019be4:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                *last_cl = save_cln;                                  
 2019be8:	e0 27 00 00 	st  %l0, [ %i4 ]                               
                fat_buf_release(fs_info);                             
 2019bec:	7f ff e4 62 	call  2012d74 <fat_buf_release>                
 2019bf0:	90 10 00 18 	mov  %i0, %o0                                  
    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;                                                        
}                                                                     
 2019bf4:	81 c7 e0 08 	ret                                            
 2019bf8:	91 e8 00 11 	restore  %g0, %l1, %o0                         
                fat_buf_release(fs_info);                             
                return rc;                                            
            }                                                         
        }                                                             
        i++;                                                          
        cl4find++;                                                    
 2019bfc:	a0 04 20 01 	inc  %l0                                       
        if (cl4find >= data_cls_val)                                  
 2019c00:	80 a4 00 14 	cmp  %l0, %l4                                  
 2019c04:	0a 80 00 03 	bcs  2019c10 <fat_scan_fat_for_free_clusters+0x19c><== ALWAYS TAKEN
 2019c08:	a6 04 e0 01 	inc  %l3                                       
            cl4find = 2;                                              
 2019c0c:	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)                                          
 2019c10:	80 a4 c0 14 	cmp  %l3, %l4                                  
 2019c14:	0a bf ff a7 	bcs  2019ab0 <fat_scan_fat_for_free_clusters+0x3c><== ALWAYS TAKEN
 2019c18:	90 10 00 18 	mov  %i0, %o0                                  
        if (cl4find >= data_cls_val)                                  
            cl4find = 2;                                              
    }                                                                 
                                                                      
        fs_info->vol.next_cl = save_cln;                              
        if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)             
 2019c1c:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
 2019c20:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
 2019c24:	02 80 00 05 	be  2019c38 <fat_scan_fat_for_free_clusters+0x1c4><== NOT EXECUTED
 2019c28:	e4 26 20 4c 	st  %l2, [ %i0 + 0x4c ]                        <== NOT EXECUTED
            fs_info->vol.free_cls -= (*cls_added);                    
 2019c2c:	c4 06 c0 00 	ld  [ %i3 ], %g2                               <== NOT EXECUTED
 2019c30:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
 2019c34:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                                                                      
    *last_cl = save_cln;                                              
 2019c38:	e4 27 00 00 	st  %l2, [ %i4 ]                               <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
 2019c3c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2019c40:	7f ff e4 4d 	call  2012d74 <fat_buf_release>                <== NOT EXECUTED
 2019c44:	a2 10 20 00 	clr  %l1                                       <== 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;                                                        
}                                                                     
 2019c48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019c4c:	91 e8 00 11 	restore  %g0, %l1, %o0                         <== NOT EXECUTED
    return RC_OK;                                                     
                                                                      
cleanup:                                                              
                                                                      
    /* cleanup activity */                                            
    fat_free_fat_clusters_chain(fs_info, (*chain));                   
 2019c50:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 2019c54:	7f ff ff 59 	call  20199b8 <fat_free_fat_clusters_chain>    <== NOT EXECUTED
 2019c58:	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);           
 2019c5c:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 2019c60:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 2019c64:	7f ff fe b4 	call  2019734 <fat_set_fat_cluster>            <== NOT EXECUTED
 2019c68:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
 2019c6c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2019c70:	7f ff e4 41 	call  2012d74 <fat_buf_release>                <== NOT EXECUTED
 2019c74:	a2 10 00 12 	mov  %l2, %l1                                  <== NOT EXECUTED
    return rc;                                                        
}                                                                     
 2019c78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019c7c:	91 e8 00 11 	restore  %g0, %l1, %o0                         <== NOT EXECUTED
 2019c80:	b0 10 00 11 	mov  %l1, %i0                                  <== NOT EXECUTED
 2019c84:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019c88:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02013080 <fat_sector_write>: fat_fs_info_t *fs_info, uint32_t start, uint32_t offset, uint32_t count, const void *buff) {
 2013080:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                 rc = RC_OK;                                   
    ssize_t             cmpltd = 0;                                   
 2013084:	a0 10 20 00 	clr  %l0                                       
    uint32_t            sec_num = start;                              
    uint32_t            ofs = offset;                                 
    uint8_t            *sec_buf;                                      
    uint32_t            c = 0;                                        
                                                                      
    while(count > 0)                                                  
 2013088:	10 80 00 1b 	b  20130f4 <fat_sector_write+0x74>             
 201308c:	a2 10 20 01 	mov  1, %l1                                    
    {                                                                 
        c = MIN(count, (fs_info->vol.bps - ofs));                     
 2013090:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
 2013094:	80 a7 40 1b 	cmp  %i5, %i3                                  
 2013098:	38 80 00 02 	bgu,a   20130a0 <fat_sector_write+0x20>        
 201309c:	ba 10 00 1b 	mov  %i3, %i5                                  
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
 20130a0:	c2 16 20 0a 	lduh  [ %i0 + 0xa ], %g1                       
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
 20130a4:	90 10 00 18 	mov  %i0, %o0                                  
 20130a8:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    while(count > 0)                                                  
    {                                                                 
        c = MIN(count, (fs_info->vol.bps - ofs));                     
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
 20130ac:	80 a7 40 01 	cmp  %i5, %g1                                  
 20130b0:	02 80 00 03 	be  20130bc <fat_sector_write+0x3c>            <== NEVER TAKEN
 20130b4:	94 10 20 02 	mov  2, %o2                                    
            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);
 20130b8:	94 10 20 01 	mov  1, %o2                                    
 20130bc:	7f ff ff a2 	call  2012f44 <fat_buf_access>                 
 20130c0:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
 20130c4:	80 a2 20 00 	cmp  %o0, 0                                    
 20130c8:	12 80 00 10 	bne  2013108 <fat_sector_write+0x88>           <== NEVER TAKEN
 20130cc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
 20130d0:	92 07 00 10 	add  %i4, %l0, %o1                             
 20130d4:	90 02 00 1a 	add  %o0, %i2, %o0                             
 20130d8:	94 10 00 1d 	mov  %i5, %o2                                  
 20130dc:	40 00 23 f3 	call  201c0a8 <memcpy>                         
 20130e0:	b6 26 c0 1d 	sub  %i3, %i5, %i3                             
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
        cmpltd +=c;                                                   
 20130e4:	a0 07 40 10 	add  %i5, %l0, %l0                             
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
 20130e8:	e2 2e 20 88 	stb  %l1, [ %i0 + 0x88 ]                       
        sec_num++;                                                    
 20130ec:	b2 06 60 01 	inc  %i1                                       
        ofs = 0;                                                      
 20130f0:	b4 10 20 00 	clr  %i2                                       
    uint32_t            sec_num = start;                              
    uint32_t            ofs = offset;                                 
    uint8_t            *sec_buf;                                      
    uint32_t            c = 0;                                        
                                                                      
    while(count > 0)                                                  
 20130f4:	80 a6 e0 00 	cmp  %i3, 0                                    
 20130f8:	32 bf ff e6 	bne,a   2013090 <fat_sector_write+0x10>        
 20130fc:	fa 16 00 00 	lduh  [ %i0 ], %i5                             
        cmpltd +=c;                                                   
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
 2013100:	81 c7 e0 08 	ret                                            
 2013104:	91 e8 00 10 	restore  %g0, %l0, %o0                         
        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)                                              
            return -1;                                                
 2013108:	a0 10 3f ff 	mov  -1, %l0                                   <== NOT EXECUTED
        cmpltd +=c;                                                   
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
 201310c:	b0 10 00 10 	mov  %l0, %i0                                  <== NOT EXECUTED
 2013110:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013114:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02019734 <fat_set_fat_cluster>: fat_set_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t in_val ) {
 2019734:	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;                               
 2019738:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
 201973c:	80 a6 60 01 	cmp  %i1, 1                                    
 2019740:	08 80 00 98 	bleu  20199a0 <fat_set_fat_cluster+0x26c>      <== NEVER TAKEN
 2019744:	ba 10 00 18 	mov  %i0, %i5                                  
 2019748:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
 201974c:	82 00 60 01 	inc  %g1                                       
 2019750:	80 a6 40 01 	cmp  %i1, %g1                                  
 2019754:	28 80 00 03 	bleu,a   2019760 <fat_set_fat_cluster+0x2c>    <== ALWAYS TAKEN
 2019758:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
 201975c:	30 80 00 91 	b,a   20199a0 <fat_set_fat_cluster+0x26c>      <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
 2019760:	84 08 60 01 	and  %g1, 1, %g2                               
 2019764:	80 88 a0 ff 	btst  0xff, %g2                                
 2019768:	02 80 00 05 	be  201977c <fat_set_fat_cluster+0x48>         
 201976c:	86 08 60 02 	and  %g1, 2, %g3                               
 2019770:	a1 36 60 01 	srl  %i1, 1, %l0                               
 2019774:	10 80 00 06 	b  201978c <fat_set_fat_cluster+0x58>          
 2019778:	a0 04 00 19 	add  %l0, %i1, %l0                             
 201977c:	80 88 e0 ff 	btst  0xff, %g3                                
 2019780:	02 80 00 03 	be  201978c <fat_set_fat_cluster+0x58>         
 2019784:	a1 2e 60 02 	sll  %i1, 2, %l0                               
 2019788:	a1 2e 60 01 	sll  %i1, 1, %l0                               
 201978c:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
 2019790:	80 88 a0 ff 	btst  0xff, %g2                                
                                                                      
    /* 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) +
 2019794:	a1 34 00 03 	srl  %l0, %g3, %l0                             
 2019798:	c6 07 60 58 	ld  [ %i5 + 0x58 ], %g3                        
          fs_info->vol.afat_loc;                                      
    ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
 201979c:	02 80 00 05 	be  20197b0 <fat_set_fat_cluster+0x7c>         
 20197a0:	a0 04 00 03 	add  %l0, %g3, %l0                             
 20197a4:	b7 36 60 01 	srl  %i1, 1, %i3                               
 20197a8:	10 80 00 07 	b  20197c4 <fat_set_fat_cluster+0x90>          
 20197ac:	b6 06 c0 19 	add  %i3, %i1, %i3                             
 20197b0:	82 08 60 02 	and  %g1, 2, %g1                               
 20197b4:	80 88 60 ff 	btst  0xff, %g1                                
 20197b8:	02 80 00 03 	be  20197c4 <fat_set_fat_cluster+0x90>         
 20197bc:	b7 2e 60 02 	sll  %i1, 2, %i3                               
 20197c0:	b7 2e 60 01 	sll  %i1, 1, %i3                               
 20197c4:	f8 17 40 00 	lduh  [ %i5 ], %i4                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
 20197c8:	90 10 00 1d 	mov  %i5, %o0                                  
 20197cc:	92 10 00 10 	mov  %l0, %o1                                  
 20197d0:	94 10 20 01 	mov  1, %o2                                    
 20197d4:	7f ff e5 dc 	call  2012f44 <fat_buf_access>                 
 20197d8:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
 20197dc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20197e0:	12 80 00 4c 	bne  2019910 <fat_set_fat_cluster+0x1dc>       <== NEVER TAKEN
 20197e4:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
    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);
 20197e8:	b9 37 20 10 	srl  %i4, 0x10, %i4                            
 20197ec:	b8 07 3f ff 	add  %i4, -1, %i4                              
 20197f0:	b8 0e c0 1c 	and  %i3, %i4, %i4                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
 20197f4:	f6 0f 60 0e 	ldub  [ %i5 + 0xe ], %i3                       
 20197f8:	80 a6 e0 02 	cmp  %i3, 2                                    
 20197fc:	02 80 00 53 	be  2019948 <fat_set_fat_cluster+0x214>        
 2019800:	80 a6 e0 04 	cmp  %i3, 4                                    
 2019804:	02 80 00 5b 	be  2019970 <fat_set_fat_cluster+0x23c>        
 2019808:	80 a6 e0 01 	cmp  %i3, 1                                    
 201980c:	12 80 00 65 	bne  20199a0 <fat_set_fat_cluster+0x26c>       <== NEVER TAKEN
 2019810:	80 8e 60 01 	btst  1, %i1                                   
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
 2019814:	02 80 00 23 	be  20198a0 <fat_set_fat_cluster+0x16c>        
 2019818:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            {                                                         
                fat16_clv = ((uint16_t  )in_val) << FAT_FAT12_SHIFT;  
                *(sec_buf + ofs) &= 0x0F;                             
 201981c:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
 2019820:	84 08 a0 0f 	and  %g2, 0xf, %g2                             
 2019824:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);    
 2019828:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 201982c:	85 2e a0 04 	sll  %i2, 4, %g2                               
 2019830:	c6 08 40 1c 	ldub  [ %g1 + %i4 ], %g3                       
 2019834:	84 10 c0 02 	or  %g3, %g2, %g2                              
 2019838:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
 201983c:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
 2019840:	82 00 7f ff 	add  %g1, -1, %g1                              
 2019844:	80 a7 00 01 	cmp  %i4, %g1                                  
 2019848:	12 80 00 0f 	bne  2019884 <fat_set_fat_cluster+0x150>       <== ALWAYS TAKEN
 201984c:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       
                {                                                     
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
 2019850:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2019854:	92 04 20 01 	add  %l0, 1, %o1                               <== NOT EXECUTED
 2019858:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 201985c:	7f ff e5 ba 	call  2012f44 <fat_buf_access>                 <== NOT EXECUTED
 2019860:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
 2019864:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 2019868:	12 80 00 2a 	bne  2019910 <fat_set_fat_cluster+0x1dc>       <== NOT EXECUTED
 201986c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                        return rc;                                    
                                                                      
                     *sec_buf &= 0x00;                                
                                                                      
                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);  
 2019870:	b5 2e a0 14 	sll  %i2, 0x14, %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 &= 0x00;                                
 2019874:	c0 28 40 00 	clrb  [ %g1 ]                                  <== NOT EXECUTED
                                                                      
                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);  
 2019878:	b5 36 a0 18 	srl  %i2, 0x18, %i2                            <== NOT EXECUTED
 201987c:	10 80 00 21 	b  2019900 <fat_set_fat_cluster+0x1cc>         <== NOT EXECUTED
 2019880:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                                                                      
                     fat_buf_mark_modified(fs_info);                  
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0x00;                     
 2019884:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2019888:	b8 07 20 01 	inc  %i4                                       
                                                                      
                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
 201988c:	b5 2e a0 14 	sll  %i2, 0x14, %i2                            
                                                                      
                     fat_buf_mark_modified(fs_info);                  
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0x00;                     
 2019890:	c0 28 40 1c 	clrb  [ %g1 + %i4 ]                            
                                                                      
                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
 2019894:	b5 36 a0 18 	srl  %i2, 0x18, %i2                            
 2019898:	10 80 00 27 	b  2019934 <fat_set_fat_cluster+0x200>         
 201989c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;    
                *(sec_buf + ofs) &= 0x00;                             
 20198a0:	c0 28 40 1c 	clrb  [ %g1 + %i4 ]                            
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);    
 20198a4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
                }                                                     
            }                                                         
            else                                                      
            {                                                         
                fat16_clv = ((uint16_t  )in_val) & FAT_FAT12_MASK;    
 20198a8:	b4 0e af ff 	and  %i2, 0xfff, %i2                           
                *(sec_buf + ofs) &= 0x00;                             
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);    
 20198ac:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
 20198b0:	84 10 80 1a 	or  %g2, %i2, %g2                              
 20198b4:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
 20198b8:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
 20198bc:	82 00 7f ff 	add  %g1, -1, %g1                              
 20198c0:	80 a7 00 01 	cmp  %i4, %g1                                  
 20198c4:	12 80 00 15 	bne  2019918 <fat_set_fat_cluster+0x1e4>       <== ALWAYS TAKEN
 20198c8:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       
                {                                                     
                    rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
 20198cc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20198d0:	92 04 20 01 	add  %l0, 1, %o1                               <== NOT EXECUTED
 20198d4:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 20198d8:	7f ff e5 9b 	call  2012f44 <fat_buf_access>                 <== NOT EXECUTED
 20198dc:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
 20198e0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 20198e4:	12 80 00 0b 	bne  2019910 <fat_set_fat_cluster+0x1dc>       <== NOT EXECUTED
 20198e8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                        return rc;                                    
                                                                      
                    *sec_buf &= 0xF0;                                 
                                                                      
                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);   
 20198ec:	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;                                 
 20198f0:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
 20198f4:	84 08 bf f0 	and  %g2, -16, %g2                             <== NOT EXECUTED
 20198f8:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
                                                                      
                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);   
 20198fc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
 2019900:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
 2019904:	b4 16 80 02 	or  %i2, %g2, %i2                              <== NOT EXECUTED
 2019908:	f4 28 40 00 	stb  %i2, [ %g1 ]                              <== NOT EXECUTED
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
 201990c:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       <== NOT EXECUTED
 2019910:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2019914:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0xF0;                     
 2019918:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 201991c:	b8 07 20 01 	inc  %i4                                       
 2019920:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
                                                                      
                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
 2019924:	b5 36 a0 08 	srl  %i2, 8, %i2                               
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0xF0;                     
 2019928:	84 08 bf f0 	and  %g2, -16, %g2                             
 201992c:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
 2019930:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2019934:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
 2019938:	b4 10 80 1a 	or  %g2, %i2, %i2                              
 201993c:	f4 28 40 1c 	stb  %i2, [ %g1 + %i4 ]                        
 2019940:	81 c7 e0 08 	ret                                            
 2019944:	81 e8 00 00 	restore                                        
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
 2019948:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 201994c:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
 2019950:	82 0e 80 01 	and  %i2, %g1, %g1                             
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
                    (uint16_t  )(CT_LE_W(in_val));                    
 2019954:	83 28 60 08 	sll  %g1, 8, %g1                               
 2019958:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            
 201995c:	b5 36 a0 18 	srl  %i2, 0x18, %i2                            
 2019960:	b4 10 40 1a 	or  %g1, %i2, %i2                              
                }                                                     
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
 2019964:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2019968:	10 80 00 0a 	b  2019990 <fat_set_fat_cluster+0x25c>         
 201996c:	f4 30 40 1c 	sth  %i2, [ %g1 + %i4 ]                        
                    (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));           
 2019970:	11 3c 00 00 	sethi  %hi(0xf0000000), %o0                    
 2019974:	7f ff fe f2 	call  201953c <CPU_swap_u32>                   
 2019978:	90 2e 80 08 	andn  %i2, %o0, %o0                            
                                                                      
            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);    
 201997c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2019980:	c4 00 40 1c 	ld  [ %g1 + %i4 ], %g2                         
 2019984:	84 08 a0 f0 	and  %g2, 0xf0, %g2                            
                                                                      
            *((uint32_t *)(sec_buf + ofs)) |= fat32_clv;              
 2019988:	90 12 00 02 	or  %o0, %g2, %o0                              
 201998c:	d0 20 40 1c 	st  %o0, [ %g1 + %i4 ]                         
 2019990:	82 10 20 01 	mov  1, %g1                                    
 2019994:	c2 2f 60 88 	stb  %g1, [ %i5 + 0x88 ]                       
 2019998:	81 c7 e0 08 	ret                                            
 201999c:	81 e8 00 00 	restore                                        
                                                                      
            fat_buf_mark_modified(fs_info);                           
            break;                                                    
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
 20199a0:	40 00 07 03 	call  201b5ac <__errno>                        <== NOT EXECUTED
 20199a4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20199a8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 20199ac:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
 20199b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20199b4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02013bf4 <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) {
 2013bf4:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int            rc = RC_OK;                                        
    int            i = 0;                                             
                                                                      
    rc = fat_sync(fs_info);                                           
 2013bf8:	90 10 00 18 	mov  %i0, %o0                                  
 2013bfc:	7f ff ff ca 	call  2013b24 <fat_sync>                       
 2013c00:	ba 10 00 18 	mov  %i0, %i5                                  
    if ( rc != RC_OK )                                                
 2013c04:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2013c08:	32 80 00 02 	bne,a   2013c10 <fat_shutdown_drive+0x1c>      <== NEVER TAKEN
 2013c0c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rc = -1;                                                      
 2013c10:	b8 10 20 00 	clr  %i4                                       
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->vhash + i;          
 2013c14:	f6 07 60 6c 	ld  [ %i5 + 0x6c ], %i3                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
 2013c18:	10 80 00 04 	b  2013c28 <fat_shutdown_drive+0x34>           
 2013c1c:	b6 06 c0 1c 	add  %i3, %i4, %i3                             
            free(node);                                               
 2013c20:	7f ff c5 cd 	call  2005354 <free>                           <== NOT EXECUTED
 2013c24:	01 00 00 00 	nop                                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
 2013c28:	7f ff d9 ed 	call  200a3dc <_Chain_Get>                     
 2013c2c:	90 10 00 1b 	mov  %i3, %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 )         
 2013c30:	80 a2 20 00 	cmp  %o0, 0                                    
 2013c34:	12 bf ff fb 	bne  2013c20 <fat_shutdown_drive+0x2c>         <== NEVER TAKEN
 2013c38:	01 00 00 00 	nop                                            
 2013c3c:	b8 07 20 0c 	add  %i4, 0xc, %i4                             
                                                                      
    rc = fat_sync(fs_info);                                           
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
 2013c40:	80 a7 20 18 	cmp  %i4, 0x18                                 
 2013c44:	32 bf ff f5 	bne,a   2013c18 <fat_shutdown_drive+0x24>      
 2013c48:	f6 07 60 6c 	ld  [ %i5 + 0x6c ], %i3                        
 2013c4c:	b8 10 20 00 	clr  %i4                                       
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
    {                                                                 
        rtems_chain_node    *node = NULL;                             
        rtems_chain_control *the_chain = fs_info->rhash + i;          
 2013c50:	f6 07 60 70 	ld  [ %i5 + 0x70 ], %i3                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
 2013c54:	10 80 00 04 	b  2013c64 <fat_shutdown_drive+0x70>           
 2013c58:	b6 06 c0 1c 	add  %i3, %i4, %i3                             
            free(node);                                               
 2013c5c:	7f ff c5 be 	call  2005354 <free>                           <== NOT EXECUTED
 2013c60:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2013c64:	7f ff d9 de 	call  200a3dc <_Chain_Get>                     
 2013c68:	90 10 00 1b 	mov  %i3, %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 )         
 2013c6c:	80 a2 20 00 	cmp  %o0, 0                                    
 2013c70:	12 bf ff fb 	bne  2013c5c <fat_shutdown_drive+0x68>         <== NEVER TAKEN
 2013c74:	01 00 00 00 	nop                                            
 2013c78:	b8 07 20 0c 	add  %i4, 0xc, %i4                             
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    for (i = 0; i < FAT_HASH_SIZE; i++)                               
 2013c7c:	80 a7 20 18 	cmp  %i4, 0x18                                 
 2013c80:	32 bf ff f5 	bne,a   2013c54 <fat_shutdown_drive+0x60>      
 2013c84:	f6 07 60 70 	ld  [ %i5 + 0x70 ], %i3                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    free(fs_info->vhash);                                             
 2013c88:	7f ff c5 b3 	call  2005354 <free>                           
 2013c8c:	d0 07 60 6c 	ld  [ %i5 + 0x6c ], %o0                        
    free(fs_info->rhash);                                             
 2013c90:	7f ff c5 b1 	call  2005354 <free>                           
 2013c94:	d0 07 60 70 	ld  [ %i5 + 0x70 ], %o0                        
                                                                      
    free(fs_info->uino);                                              
 2013c98:	7f ff c5 af 	call  2005354 <free>                           
 2013c9c:	d0 07 60 74 	ld  [ %i5 + 0x74 ], %o0                        
    free(fs_info->sec_buf);                                           
 2013ca0:	7f ff c5 ad 	call  2005354 <free>                           
 2013ca4:	d0 07 60 90 	ld  [ %i5 + 0x90 ], %o0                        
    close(fs_info->vol.fd);                                           
 2013ca8:	7f ff c4 ee 	call  2005060 <close>                          
 2013cac:	d0 07 60 60 	ld  [ %i5 + 0x60 ], %o0                        
                                                                      
    if (rc)                                                           
 2013cb0:	80 a6 20 00 	cmp  %i0, 0                                    
 2013cb4:	02 80 00 06 	be  2013ccc <fat_shutdown_drive+0xd8>          <== ALWAYS TAKEN
 2013cb8:	01 00 00 00 	nop                                            
        errno = EIO;                                                  
 2013cbc:	40 00 1e 3c 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2013cc0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2013cc4:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
 2013cc8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    return rc;                                                        
}                                                                     
 2013ccc:	81 c7 e0 08 	ret                                            
 2013cd0:	81 e8 00 00 	restore                                        
                                                                      

02013b24 <fat_sync>: return RC_OK; } int fat_sync(fat_fs_info_t *fs_info) {
 2013b24:	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)                               
 2013b28:	c4 0e 20 0e 	ldub  [ %i0 + 0xe ], %g2                       
    return RC_OK;                                                     
}                                                                     
                                                                      
int                                                                   
fat_sync(fat_fs_info_t *fs_info)                                      
{                                                                     
 2013b2c:	ba 10 00 18 	mov  %i0, %i5                                  
 *     RC_OK on success, or -1 if error occured (errno set appropriately)
 */                                                                   
static int                                                            
fat_fat32_update_fsinfo_sector(fat_fs_info_t *fs_info)                
{                                                                     
    ssize_t ret1 = 0, ret2 = 0;                                       
 2013b30:	90 10 20 00 	clr  %o0                                       
                                                                      
    if (fs_info->vol.type == FAT_FAT32)                               
 2013b34:	80 a0 a0 04 	cmp  %g2, 4                                    
 2013b38:	12 80 00 20 	bne  2013bb8 <fat_sync+0x94>                   
 2013b3c:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        uint32_t free_count = fs_info->vol.free_cls;                  
 2013b40:	f6 06 20 44 	ld  [ %i0 + 0x44 ], %i3                        
        uint32_t next_free = fs_info->vol.next_cl;                    
                                                                      
        if (free_count != fs_info->vol.free_cls_in_fs_info)           
 2013b44:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
 2013b48:	80 a6 c0 01 	cmp  %i3, %g1                                  
 2013b4c:	02 80 00 0d 	be  2013b80 <fat_sync+0x5c>                    <== ALWAYS TAKEN
 2013b50:	f8 06 20 4c 	ld  [ %i0 + 0x4c ], %i4                        
        {                                                             
            uint32_t le_free_count = CT_LE_L(free_count);             
 2013b54:	7f ff fc 65 	call  2012ce8 <CPU_swap_u32>                   <== NOT EXECUTED
 2013b58:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
                                                                      
            fs_info->vol.free_cls_in_fs_info = free_count;            
                                                                      
            ret1 = fat_sector_write(fs_info,                          
 2013b5c:	d2 16 20 40 	lduh  [ %i0 + 0x40 ], %o1                      <== 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);             
 2013b60:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          <== NOT EXECUTED
                                                                      
            fs_info->vol.free_cls_in_fs_info = free_count;            
 2013b64:	f6 26 20 48 	st  %i3, [ %i0 + 0x48 ]                        <== NOT EXECUTED
                                                                      
            ret1 = fat_sector_write(fs_info,                          
 2013b68:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2013b6c:	94 10 21 e8 	mov  0x1e8, %o2                                <== NOT EXECUTED
 2013b70:	96 10 20 04 	mov  4, %o3                                    <== NOT EXECUTED
 2013b74:	7f ff fd 43 	call  2013080 <fat_sector_write>               <== NOT EXECUTED
 2013b78:	98 07 bf fc 	add  %fp, -4, %o4                              <== NOT EXECUTED
 2013b7c:	b4 10 00 08 	mov  %o0, %i2                                  <== 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)             
 2013b80:	c4 07 60 50 	ld  [ %i5 + 0x50 ], %g2                        
 2013b84:	80 a7 00 02 	cmp  %i4, %g2                                  
 2013b88:	02 80 00 0c 	be  2013bb8 <fat_sync+0x94>                    <== NEVER TAKEN
 2013b8c:	90 10 20 00 	clr  %o0                                       
        {                                                             
            uint32_t le_next_free = CT_LE_L(next_free);               
 2013b90:	7f ff fc 56 	call  2012ce8 <CPU_swap_u32>                   
 2013b94:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
            fs_info->vol.next_cl_in_fs_info = next_free;              
                                                                      
            ret2 = fat_sector_write(fs_info,                          
 2013b98:	d2 17 60 40 	lduh  [ %i5 + 0x40 ], %o1                      
                                    &le_free_count);                  
        }                                                             
                                                                      
        if (next_free != fs_info->vol.next_cl_in_fs_info)             
        {                                                             
            uint32_t le_next_free = CT_LE_L(next_free);               
 2013b9c:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
            fs_info->vol.next_cl_in_fs_info = next_free;              
 2013ba0:	f8 27 60 50 	st  %i4, [ %i5 + 0x50 ]                        
                                                                      
            ret2 = fat_sector_write(fs_info,                          
 2013ba4:	90 10 00 1d 	mov  %i5, %o0                                  
 2013ba8:	94 10 21 ec 	mov  0x1ec, %o2                                
 2013bac:	96 10 20 04 	mov  4, %o3                                    
 2013bb0:	7f ff fd 34 	call  2013080 <fat_sector_write>               
 2013bb4:	98 07 bf fc 	add  %fp, -4, %o4                              
                                    sizeof(le_next_free),             
                                    &le_next_free);                   
        }                                                             
    }                                                                 
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) )                                   
 2013bb8:	80 a2 20 00 	cmp  %o0, 0                                    
 2013bbc:	06 80 00 04 	bl  2013bcc <fat_sync+0xa8>                    <== NEVER TAKEN
 2013bc0:	80 a6 a0 00 	cmp  %i2, 0                                    
 2013bc4:	16 80 00 03 	bge  2013bd0 <fat_sync+0xac>                   <== ALWAYS TAKEN
 2013bc8:	b0 10 20 00 	clr  %i0                                       
{                                                                     
    int rc = RC_OK;                                                   
                                                                      
    rc = fat_fat32_update_fsinfo_sector(fs_info);                     
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
 2013bcc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
    fat_buf_release(fs_info);                                         
 2013bd0:	7f ff fc 69 	call  2012d74 <fat_buf_release>                
 2013bd4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)     
 2013bd8:	7f ff f5 bb 	call  20112c4 <rtems_bdbuf_syncdev>            
 2013bdc:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
 2013be0:	80 a2 20 00 	cmp  %o0, 0                                    
 2013be4:	32 80 00 02 	bne,a   2013bec <fat_sync+0xc8>                <== NEVER TAKEN
 2013be8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rc = -1;                                                      
                                                                      
    return rc;                                                        
}                                                                     
 2013bec:	81 c7 e0 08 	ret                                            
 2013bf0:	81 e8 00 00 	restore                                        
                                                                      

02032668 <fchdir>: /** * compatible with SVr4, 4.4BSD and X/OPEN - Change Directory */ int fchdir( int fd ) {
 2032668:	9d e3 bf 40 	save  %sp, -192, %sp                           
                                                                      
  st.st_mode = 0;                                                     
  st.st_uid = 0;                                                      
  st.st_gid = 0;                                                      
                                                                      
  rtems_libio_check_fd( fd );                                         
 203266c:	03 00 81 77 	sethi  %hi(0x205dc00), %g1                     
 2032670:	c2 00 61 10 	ld  [ %g1 + 0x110 ], %g1	! 205dd10 <rtems_libio_number_iops>
  int rv = 0;                                                         
  rtems_libio_t *iop;                                                 
  struct stat st;                                                     
  rtems_filesystem_location_info_t loc;                               
                                                                      
  st.st_mode = 0;                                                     
 2032674:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
  st.st_uid = 0;                                                      
 2032678:	c0 37 bf ca 	clrh  [ %fp + -54 ]                            
  st.st_gid = 0;                                                      
                                                                      
  rtems_libio_check_fd( fd );                                         
 203267c:	80 a6 00 01 	cmp  %i0, %g1                                  
 2032680:	1a 80 00 0c 	bcc  20326b0 <fchdir+0x48>                     
 2032684:	c0 37 bf cc 	clrh  [ %fp + -52 ]                            
  iop = rtems_libio_iop( fd );                                        
 2032688:	83 2e 20 03 	sll  %i0, 3, %g1                               
 203268c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2032690:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2032694:	03 00 81 87 	sethi  %hi(0x2061c00), %g1                     
 2032698:	fa 00 62 b4 	ld  [ %g1 + 0x2b4 ], %i5	! 2061eb4 <rtems_libio_iops>
 203269c:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open( iop );                                   
 20326a0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 20326a4:	80 88 61 00 	btst  0x100, %g1                               
 20326a8:	32 80 00 08 	bne,a   20326c8 <fchdir+0x60>                  
 20326ac:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 20326b0:	40 00 10 e9 	call  2036a54 <__errno>                        
 20326b4:	b0 10 3f ff 	mov  -1, %i0                                   
 20326b8:	82 10 20 09 	mov  9, %g1                                    
 20326bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 20326c0:	81 c7 e0 08 	ret                                            
 20326c4:	81 e8 00 00 	restore                                        
  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 );                               
 20326c8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 20326cc:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 20326d0:	9f c0 40 00 	call  %g1                                      
 20326d4:	b8 07 60 14 	add  %i5, 0x14, %i4                            
                                                                      
  rtems_filesystem_instance_lock( &iop->pathinfo );                   
  rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );     
 20326d8:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 20326dc:	90 10 00 1c 	mov  %i4, %o0                                  
 20326e0:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
 20326e4:	9f c0 40 00 	call  %g1                                      
 20326e8:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( rv == 0 ) {                                                    
 20326ec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20326f0:	32 80 00 13 	bne,a   203273c <fchdir+0xd4>                  <== NEVER TAKEN
 20326f4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
    bool access_ok = rtems_filesystem_check_access(                   
 20326f8:	d2 07 bf c4 	ld  [ %fp + -60 ], %o1                         
 20326fc:	d4 17 bf ca 	lduh  [ %fp + -54 ], %o2                       
 2032700:	d6 17 bf cc 	lduh  [ %fp + -52 ], %o3                       
 2032704:	7f ff 6e da 	call  200e26c <rtems_filesystem_check_access>  
 2032708:	90 10 20 01 	mov  1, %o0                                    
      st.st_mode,                                                     
      st.st_uid,                                                      
      st.st_gid                                                       
    );                                                                
                                                                      
    if ( access_ok ) {                                                
 203270c:	80 8a 20 ff 	btst  0xff, %o0                                
 2032710:	02 80 00 06 	be  2032728 <fchdir+0xc0>                      
 2032714:	90 07 bf a0 	add  %fp, -96, %o0                             
      rtems_filesystem_location_clone( &loc, &iop->pathinfo );        
 2032718:	7f ff 6d 8e 	call  200dd50 <rtems_filesystem_location_clone>
 203271c:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
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;
 2032720:	10 80 00 07 	b  203273c <fchdir+0xd4>                       
 2032724:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
    } else {                                                          
      errno = EACCES;                                                 
 2032728:	40 00 10 cb 	call  2036a54 <__errno>                        
 203272c:	b0 10 3f ff 	mov  -1, %i0                                   
 2032730:	82 10 20 0d 	mov  0xd, %g1                                  
 2032734:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2032738:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
 203273c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 2032740:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 2032744:	9f c0 40 00 	call  %g1                                      
 2032748:	01 00 00 00 	nop                                            
      rv = -1;                                                        
    }                                                                 
  }                                                                   
  rtems_filesystem_instance_unlock( &iop->pathinfo );                 
                                                                      
  if ( rv == 0 ) {                                                    
 203274c:	80 a6 20 00 	cmp  %i0, 0                                    
 2032750:	12 80 00 05 	bne  2032764 <fchdir+0xfc>                     
 2032754:	01 00 00 00 	nop                                            
    rv = rtems_filesystem_chdir( &loc );                              
 2032758:	7f ff c4 69 	call  20238fc <rtems_filesystem_chdir>         
 203275c:	90 07 bf a0 	add  %fp, -96, %o0                             
 2032760:	b0 10 00 08 	mov  %o0, %i0                                  
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2032764:	81 c7 e0 08 	ret                                            
 2032768:	81 e8 00 00 	restore                                        
                                                                      

02023be4 <fchmod>: /** * POSIX 1003.1b 5.6.4 - Change File Modes */ int fchmod( int fd, mode_t mode ) {
 2023be4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv;                                                             
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
 2023be8:	03 00 81 77 	sethi  %hi(0x205dc00), %g1                     
 2023bec:	c2 00 61 10 	ld  [ %g1 + 0x110 ], %g1	! 205dd10 <rtems_libio_number_iops>
 2023bf0:	80 a6 00 01 	cmp  %i0, %g1                                  
 2023bf4:	2a 80 00 03 	bcs,a   2023c00 <fchmod+0x1c>                  
 2023bf8:	83 2e 20 03 	sll  %i0, 3, %g1                               
 2023bfc:	30 80 00 0a 	b,a   2023c24 <fchmod+0x40>                    
  iop = rtems_libio_iop( fd );                                        
 2023c00:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2023c04:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2023c08:	03 00 81 87 	sethi  %hi(0x2061c00), %g1                     
 2023c0c:	fa 00 62 b4 	ld  [ %g1 + 0x2b4 ], %i5	! 2061eb4 <rtems_libio_iops>
 2023c10:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
 2023c14:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 2023c18:	80 88 61 00 	btst  0x100, %g1                               
 2023c1c:	32 80 00 06 	bne,a   2023c34 <fchmod+0x50>                  
 2023c20:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 2023c24:	40 00 4b 8c 	call  2036a54 <__errno>                        
 2023c28:	01 00 00 00 	nop                                            
 2023c2c:	10 80 00 1b 	b  2023c98 <fchmod+0xb4>                       
 2023c30:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      
  if (iop->pathinfo.mt_entry->writeable) {                            
 2023c34:	c2 0a 20 29 	ldub  [ %o0 + 0x29 ], %g1                      
 2023c38:	80 a0 60 00 	cmp  %g1, 0                                    
 2023c3c:	02 80 00 14 	be  2023c8c <fchmod+0xa8>                      <== NEVER TAKEN
 2023c40:	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 );                               
 2023c44:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 2023c48:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 2023c4c:	9f c0 40 00 	call  %g1                                      
 2023c50:	01 00 00 00 	nop                                            
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
 2023c54:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 2023c58:	90 07 60 14 	add  %i5, 0x14, %o0                            
 2023c5c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2023c60:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1                        
 2023c64:	9f c0 40 00 	call  %g1                                      
 2023c68:	92 10 00 19 	mov  %i1, %o1                                  
 2023c6c:	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;
 2023c70:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
 2023c74:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 2023c78:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 2023c7c:	9f c0 40 00 	call  %g1                                      
 2023c80:	01 00 00 00 	nop                                            
 2023c84:	81 c7 e0 08 	ret                                            
 2023c88:	81 e8 00 00 	restore                                        
    rtems_filesystem_instance_unlock( &iop->pathinfo );               
  } else {                                                            
    errno = EROFS;                                                    
 2023c8c:	40 00 4b 72 	call  2036a54 <__errno>                        <== NOT EXECUTED
 2023c90:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2023c94:	82 10 20 1e 	mov  0x1e, %g1	! 1e <PROM_START+0x1e>          <== NOT EXECUTED
 2023c98:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2023c9c:	81 c7 e0 08 	ret                                            
 2023ca0:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

02023ca4 <fchown>: /** * POSIX 1003.1b 5.6.5 - Change Owner and Group of a File */ int fchown( int fd, uid_t owner, gid_t group ) {
 2023ca4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
 2023ca8:	03 00 81 77 	sethi  %hi(0x205dc00), %g1                     
 2023cac:	c2 00 61 10 	ld  [ %g1 + 0x110 ], %g1	! 205dd10 <rtems_libio_number_iops>
 2023cb0:	80 a6 00 01 	cmp  %i0, %g1                                  
 2023cb4:	2a 80 00 03 	bcs,a   2023cc0 <fchown+0x1c>                  
 2023cb8:	83 2e 20 03 	sll  %i0, 3, %g1                               
 2023cbc:	30 80 00 0a 	b,a   2023ce4 <fchown+0x40>                    
  iop = rtems_libio_iop( fd );                                        
 2023cc0:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2023cc4:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2023cc8:	03 00 81 87 	sethi  %hi(0x2061c00), %g1                     
 2023ccc:	fa 00 62 b4 	ld  [ %g1 + 0x2b4 ], %i5	! 2061eb4 <rtems_libio_iops>
 2023cd0:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
 2023cd4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 2023cd8:	80 88 61 00 	btst  0x100, %g1                               
 2023cdc:	32 80 00 06 	bne,a   2023cf4 <fchown+0x50>                  
 2023ce0:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 2023ce4:	40 00 4b 5c 	call  2036a54 <__errno>                        
 2023ce8:	01 00 00 00 	nop                                            
 2023cec:	10 80 00 1c 	b  2023d5c <fchown+0xb8>                       
 2023cf0:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      
  if (iop->pathinfo.mt_entry->writeable) {                            
 2023cf4:	c2 0a 20 29 	ldub  [ %o0 + 0x29 ], %g1                      
 2023cf8:	80 a0 60 00 	cmp  %g1, 0                                    
 2023cfc:	02 80 00 15 	be  2023d50 <fchown+0xac>                      <== NEVER TAKEN
 2023d00:	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 );                               
 2023d04:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 2023d08:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 2023d0c:	9f c0 40 00 	call  %g1                                      
 2023d10:	01 00 00 00 	nop                                            
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rv = (*iop->pathinfo.mt_entry->ops->chown_h)(                     
 2023d14:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 2023d18:	90 07 60 14 	add  %i5, 0x14, %o0                            
 2023d1c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2023d20:	92 10 00 19 	mov  %i1, %o1                                  
 2023d24:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
 2023d28:	9f c0 40 00 	call  %g1                                      
 2023d2c:	94 10 00 1a 	mov  %i2, %o2                                  
 2023d30:	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;
 2023d34:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
 2023d38:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 2023d3c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 2023d40:	9f c0 40 00 	call  %g1                                      
 2023d44:	01 00 00 00 	nop                                            
 2023d48:	81 c7 e0 08 	ret                                            
 2023d4c:	81 e8 00 00 	restore                                        
      owner,                                                          
      group                                                           
    );                                                                
    rtems_filesystem_instance_unlock( &iop->pathinfo );               
  } else {                                                            
    errno = EROFS;                                                    
 2023d50:	40 00 4b 41 	call  2036a54 <__errno>                        <== NOT EXECUTED
 2023d54:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2023d58:	82 10 20 1e 	mov  0x1e, %g1	! 1e <PROM_START+0x1e>          <== NOT EXECUTED
 2023d5c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2023d60:	81 c7 e0 08 	ret                                            
 2023d64:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

0202f720 <fcntl>: int fcntl( int fd, int cmd, ... ) {
 202f720:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
 202f724:	05 00 80 d7 	sethi  %hi(0x2035c00), %g2                     
 202f728:	c4 00 a0 8c 	ld  [ %g2 + 0x8c ], %g2	! 2035c8c <rtems_libio_number_iops>
  ...                                                                 
)                                                                     
{                                                                     
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
 202f72c:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
 202f730:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
 202f734:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
 202f738:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
 202f73c:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
 202f740:	80 a6 00 02 	cmp  %i0, %g2                                  
 202f744:	1a 80 00 0c 	bcc  202f774 <fcntl+0x54>                      
 202f748:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
  iop = rtems_libio_iop( fd );                                        
 202f74c:	85 2e 20 03 	sll  %i0, 3, %g2                               
 202f750:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 202f754:	b0 26 00 02 	sub  %i0, %g2, %i0                             
 202f758:	05 00 81 1a 	sethi  %hi(0x2046800), %g2                     
 202f75c:	fa 00 a0 38 	ld  [ %g2 + 0x38 ], %i5	! 2046838 <rtems_libio_iops>
 202f760:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
 202f764:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
 202f768:	80 8a 21 00 	btst  0x100, %o0                               
 202f76c:	12 80 00 06 	bne  202f784 <fcntl+0x64>                      
 202f770:	80 a6 60 09 	cmp  %i1, 9                                    
 202f774:	7f ff c4 ab 	call  2020a20 <__errno>                        
 202f778:	01 00 00 00 	nop                                            
 202f77c:	10 80 00 5d 	b  202f8f0 <fcntl+0x1d0>                       
 202f780:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
 202f784:	18 80 00 58 	bgu  202f8e4 <fcntl+0x1c4>                     
 202f788:	85 2e 60 02 	sll  %i1, 2, %g2                               
 202f78c:	07 00 80 bd 	sethi  %hi(0x202f400), %g3                     
 202f790:	86 10 e2 f8 	or  %g3, 0x2f8, %g3	! 202f6f8 <_calloc_r+0x14> 
 202f794:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
 202f798:	81 c0 80 00 	jmp  %g2                                       
 202f79c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * FIXME: We ignore the start value fd2 for the file descriptor search.  This
   * is not POSIX conform.                                            
   */                                                                 
  rtems_libio_t *diop = rtems_libio_allocate();                       
 202f7a0:	7f ff 63 05 	call  20083b4 <rtems_libio_allocate>           
 202f7a4:	01 00 00 00 	nop                                            
                                                                      
  if (diop != NULL) {                                                 
 202f7a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 202f7ac:	02 80 00 62 	be  202f934 <fcntl+0x214>                      
 202f7b0:	b0 10 3f ff 	mov  -1, %i0                                   
    int oflag = rtems_libio_to_fcntl_flags( iop->flags );             
 202f7b4:	7f ff 62 ea 	call  200835c <rtems_libio_to_fcntl_flags>     
 202f7b8:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
                                                                      
    oflag &= ~O_CREAT;                                                
    diop->flags |= rtems_libio_fcntl_flags( oflag );                  
 202f7bc:	f4 07 20 10 	ld  [ %i4 + 0x10 ], %i2                        
  rtems_libio_t *diop = rtems_libio_allocate();                       
                                                                      
  if (diop != NULL) {                                                 
    int oflag = rtems_libio_to_fcntl_flags( iop->flags );             
                                                                      
    oflag &= ~O_CREAT;                                                
 202f7c0:	b6 0a 3d ff 	and  %o0, -513, %i3                            
    diop->flags |= rtems_libio_fcntl_flags( oflag );                  
 202f7c4:	7f ff 62 d9 	call  2008328 <rtems_libio_fcntl_flags>        
 202f7c8:	90 10 00 1b 	mov  %i3, %o0                                  
 202f7cc:	90 12 00 1a 	or  %o0, %i2, %o0                              
 202f7d0:	d0 27 20 10 	st  %o0, [ %i4 + 0x10 ]                        
                                                                      
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;
 202f7d4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
 202f7d8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 202f7dc:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 202f7e0:	9f c0 40 00 	call  %g1                                      
 202f7e4:	01 00 00 00 	nop                                            
                                                                      
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
 202f7e8:	92 07 60 14 	add  %i5, 0x14, %o1                            
 202f7ec:	7f ff 9d 20 	call  2016c6c <rtems_filesystem_location_clone>
 202f7f0:	90 07 20 14 	add  %i4, 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;
 202f7f4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
 202f7f8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 202f7fc:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 202f800:	9f c0 40 00 	call  %g1                                      
 202f804:	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 );  
 202f808:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
 202f80c:	90 10 00 1c 	mov  %i4, %o0                                  
 202f810:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 202f814:	92 10 20 00 	clr  %o1                                       
 202f818:	94 10 00 1b 	mov  %i3, %o2                                  
 202f81c:	9f c0 40 00 	call  %g1                                      
 202f820:	96 10 20 00 	clr  %o3                                       
    if ( rv == 0 ) {                                                  
 202f824:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 202f828:	12 80 00 11 	bne  202f86c <fcntl+0x14c>                     <== NEVER TAKEN
 202f82c:	03 00 81 1a 	sethi  %hi(0x2046800), %g1                     
      rv = diop - rtems_libio_iops;                                   
 202f830:	f0 00 60 38 	ld  [ %g1 + 0x38 ], %i0	! 2046838 <rtems_libio_iops>
 202f834:	b8 27 00 18 	sub  %i4, %i0, %i4                             
 202f838:	b9 3f 20 03 	sra  %i4, 3, %i4                               
 202f83c:	85 2f 20 03 	sll  %i4, 3, %g2                               
 202f840:	83 2f 20 06 	sll  %i4, 6, %g1                               
 202f844:	82 00 80 01 	add  %g2, %g1, %g1                             
 202f848:	85 28 60 06 	sll  %g1, 6, %g2                               
 202f84c:	82 00 40 02 	add  %g1, %g2, %g1                             
 202f850:	82 00 40 1c 	add  %g1, %i4, %g1                             
 202f854:	b1 28 60 0f 	sll  %g1, 0xf, %i0                             
 202f858:	82 00 40 18 	add  %g1, %i0, %g1                             
 202f85c:	83 28 60 03 	sll  %g1, 3, %g1                               
 202f860:	b8 00 40 1c 	add  %g1, %i4, %i4                             
 202f864:	10 80 00 25 	b  202f8f8 <fcntl+0x1d8>                       
 202f868:	b0 20 00 1c 	neg  %i4, %i0                                  
    } else {                                                          
      rtems_libio_free( diop );                                       
 202f86c:	7f ff 62 e9 	call  2008410 <rtems_libio_free>               <== NOT EXECUTED
 202f870:	90 10 00 1c 	mov  %i4, %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) {                                                     
 202f874:	10 80 00 22 	b  202f8fc <fcntl+0x1dc>                       <== NOT EXECUTED
 202f878:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
      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);          
 202f87c:	b1 32 20 0b 	srl  %o0, 0xb, %i0                             
 202f880:	10 80 00 21 	b  202f904 <fcntl+0x1e4>                       
 202f884:	b0 0e 20 01 	and  %i0, 1, %i0                               
       *  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 ) )                                        
 202f888:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 202f88c:	80 a0 60 00 	cmp  %g1, 0                                    
 202f890:	22 80 00 0e 	be,a   202f8c8 <fcntl+0x1a8>                   
 202f894:	90 0a 37 ff 	and  %o0, -2049, %o0                           
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
 202f898:	10 80 00 0c 	b  202f8c8 <fcntl+0x1a8>                       
 202f89c:	90 12 28 00 	or  %o0, 0x800, %o0                            
      else                                                            
        iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;                     
      break;                                                          
                                                                      
    case F_GETFL:        /* more flags (cloexec) */                   
      ret = rtems_libio_to_fcntl_flags( iop->flags );                 
 202f8a0:	7f ff 62 af 	call  200835c <rtems_libio_to_fcntl_flags>     
 202f8a4:	01 00 00 00 	nop                                            
 202f8a8:	10 80 00 14 	b  202f8f8 <fcntl+0x1d8>                       
 202f8ac:	b0 10 00 08 	mov  %o0, %i0                                  
      break;                                                          
                                                                      
    case F_SETFL:                                                     
      flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );           
 202f8b0:	7f ff 62 9e 	call  2008328 <rtems_libio_fcntl_flags>        
 202f8b4:	d0 00 40 00 	ld  [ %g1 ], %o0                               
                                                                      
      /*                                                              
       *  XXX If we are turning on append, should we seek to the end? 
       */                                                             
                                                                      
      iop->flags = (iop->flags & ~mask) | (flags & mask);             
 202f8b8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 202f8bc:	90 0a 22 01 	and  %o0, 0x201, %o0                           
 202f8c0:	82 08 7d fe 	and  %g1, -514, %g1                            
 202f8c4:	90 12 00 01 	or  %o0, %g1, %o0                              
 202f8c8:	d0 27 60 10 	st  %o0, [ %i5 + 0x10 ]                        
{                                                                     
  rtems_libio_t *iop;                                                 
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
 202f8cc:	10 80 00 0e 	b  202f904 <fcntl+0x1e4>                       
 202f8d0:	b0 10 20 00 	clr  %i0                                       
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    case F_GETOWN:       /*  for sockets. */                          
      errno = ENOTSUP;                                                
 202f8d4:	7f ff c4 53 	call  2020a20 <__errno>                        
 202f8d8:	01 00 00 00 	nop                                            
 202f8dc:	10 80 00 05 	b  202f8f0 <fcntl+0x1d0>                       
 202f8e0:	82 10 20 86 	mov  0x86, %g1	! 86 <PROM_START+0x86>          
      ret = -1;                                                       
      break;                                                          
                                                                      
    default:                                                          
      errno = EINVAL;                                                 
 202f8e4:	7f ff c4 4f 	call  2020a20 <__errno>                        
 202f8e8:	01 00 00 00 	nop                                            
 202f8ec:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 202f8f0:	10 80 00 10 	b  202f930 <fcntl+0x210>                       
 202f8f4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  /*                                                                  
   *  If we got this far successfully, then we give the optional      
   *  filesystem specific handler a chance to process this.           
   */                                                                 
                                                                      
  if (ret >= 0) {                                                     
 202f8f8:	80 a6 20 00 	cmp  %i0, 0                                    
 202f8fc:	06 80 00 0e 	bl  202f934 <fcntl+0x214>                      <== NEVER TAKEN
 202f900:	01 00 00 00 	nop                                            
    int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );         
 202f904:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 202f908:	90 10 00 1d 	mov  %i5, %o0                                  
 202f90c:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
 202f910:	9f c0 40 00 	call  %g1                                      
 202f914:	92 10 00 19 	mov  %i1, %o1                                  
    if (err) {                                                        
 202f918:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 202f91c:	02 80 00 06 	be  202f934 <fcntl+0x214>                      <== ALWAYS TAKEN
 202f920:	01 00 00 00 	nop                                            
      errno = err;                                                    
 202f924:	7f ff c4 3f 	call  2020a20 <__errno>                        <== NOT EXECUTED
 202f928:	01 00 00 00 	nop                                            <== NOT EXECUTED
 202f92c:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_is_open(iop);                                     
 202f930:	b0 10 3f ff 	mov  -1, %i0                                   
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
 202f934:	81 c7 e0 08 	ret                                            
 202f938:	81 e8 00 00 	restore                                        
                                                                      

0200dd0c <fifo_open>: int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) {
 200dd0c:	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) {                              
 200dd10:	3b 00 80 8c 	sethi  %hi(0x2023000), %i5                     
 200dd14:	c2 07 61 80 	ld  [ %i5 + 0x180 ], %g1	! 2023180 <pipe_semaphore>
                                                                      
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
 200dd18:	b6 10 00 18 	mov  %i0, %i3                                  
                                                                      
static int pipe_lock(void)                                            
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
 200dd1c:	80 a0 60 00 	cmp  %g1, 0                                    
 200dd20:	02 80 00 0c 	be  200dd50 <fifo_open+0x44>                   
 200dd24:	b8 17 61 80 	or  %i5, 0x180, %i4                            
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
    sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 200dd28:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     
 200dd2c:	d0 00 61 80 	ld  [ %g1 + 0x180 ], %o0	! 2023180 <pipe_semaphore>
 200dd30:	92 10 20 00 	clr  %o1                                       
 200dd34:	7f ff ec 88 	call  2008f54 <rtems_semaphore_obtain>         
 200dd38:	94 10 20 00 	clr  %o2                                       
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
 200dd3c:	80 a2 20 00 	cmp  %o0, 0                                    
 200dd40:	22 80 01 00 	be,a   200e140 <fifo_open+0x434>               <== ALWAYS TAKEN
 200dd44:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
    return 0;                                                         
  } else {                                                            
    return -ENOMEM;                                                   
 200dd48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200dd4c:	91 e8 3f f4 	restore  %g0, -12, %o0                         <== NOT EXECUTED
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
 200dd50:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     
 200dd54:	d0 00 63 00 	ld  [ %g1 + 0x300 ], %o0	! 2023300 <rtems_libio_semaphore>
 200dd58:	92 10 20 00 	clr  %o1                                       
 200dd5c:	7f ff ec 7e 	call  2008f54 <rtems_semaphore_obtain>         
 200dd60:	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) {                            
 200dd64:	c2 07 61 80 	ld  [ %i5 + 0x180 ], %g1                       
 200dd68:	80 a0 60 00 	cmp  %g1, 0                                    
 200dd6c:	12 80 00 0a 	bne  200dd94 <fifo_open+0x88>                  <== NEVER TAKEN
 200dd70:	ba 10 20 00 	clr  %i5                                       
      sc = rtems_semaphore_create(                                    
 200dd74:	11 14 12 54 	sethi  %hi(0x50495000), %o0                    
 200dd78:	92 10 20 01 	mov  1, %o1                                    
 200dd7c:	90 12 20 45 	or  %o0, 0x45, %o0                             
 200dd80:	94 10 20 54 	mov  0x54, %o2                                 
 200dd84:	96 10 20 00 	clr  %o3                                       
 200dd88:	7f ff eb d6 	call  2008ce0 <rtems_semaphore_create>         
 200dd8c:	98 10 00 1c 	mov  %i4, %o4                                  
 200dd90:	ba 10 00 08 	mov  %o0, %i5                                  
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
 200dd94:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     
 200dd98:	7f ff ec b8 	call  2009078 <rtems_semaphore_release>        
 200dd9c:	d0 00 63 00 	ld  [ %g1 + 0x300 ], %o0	! 2023300 <rtems_libio_semaphore>
    }                                                                 
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
 200dda0:	80 a7 60 00 	cmp  %i5, 0                                    
 200dda4:	02 bf ff e1 	be  200dd28 <fifo_open+0x1c>                   
 200dda8:	b0 10 3f f4 	mov  -12, %i0                                  
 200ddac:	81 c7 e0 08 	ret                                            
 200ddb0:	81 e8 00 00 	restore                                        
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
 200ddb4:	7f ff db b5 	call  2004c88 <malloc>                         
 200ddb8:	90 10 20 34 	mov  0x34, %o0                                 
  if (pipe == NULL)                                                   
 200ddbc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200ddc0:	02 80 00 e4 	be  200e150 <fifo_open+0x444>                  <== NEVER TAKEN
 200ddc4:	92 10 20 00 	clr  %o1                                       
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
 200ddc8:	40 00 12 ce 	call  2012900 <memset>                         
 200ddcc:	94 10 20 34 	mov  0x34, %o2                                 
                                                                      
  pipe->Size = PIPE_BUF;                                              
 200ddd0:	82 10 22 00 	mov  0x200, %g1                                
  pipe->Buffer = malloc(pipe->Size);                                  
 200ddd4:	90 10 22 00 	mov  0x200, %o0                                
 200ddd8:	7f ff db ac 	call  2004c88 <malloc>                         
 200dddc:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
  if (! pipe->Buffer)                                                 
 200dde0:	80 a2 20 00 	cmp  %o0, 0                                    
 200dde4:	02 80 00 40 	be  200dee4 <fifo_open+0x1d8>                  <== NEVER TAKEN
 200dde8:	d0 27 40 00 	st  %o0, [ %i5 ]                               
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'r', c),                          
 200ddec:	39 00 80 8a 	sethi  %hi(0x2022800), %i4                     
 200ddf0:	d0 4f 22 38 	ldsb  [ %i4 + 0x238 ], %o0	! 2022a38 <c.7185>  
  if (! pipe->Buffer)                                                 
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
 200ddf4:	35 14 12 5c 	sethi  %hi(0x50497000), %i2                    
 200ddf8:	82 16 a2 00 	or  %i2, 0x200, %g1	! 50497200 <RAM_END+0x4e097200>
 200ddfc:	92 10 20 00 	clr  %o1                                       
 200de00:	90 12 00 01 	or  %o0, %g1, %o0                              
 200de04:	94 10 20 00 	clr  %o2                                       
 200de08:	40 00 05 f1 	call  200f5cc <rtems_barrier_create>           
 200de0c:	96 07 60 2c 	add  %i5, 0x2c, %o3                            
 200de10:	80 a2 20 00 	cmp  %o0, 0                                    
 200de14:	12 80 00 32 	bne  200dedc <fifo_open+0x1d0>                 
 200de18:	d0 4f 22 38 	ldsb  [ %i4 + 0x238 ], %o0                     
        rtems_build_name ('P', 'I', 'r', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->readBarrier) != RTEMS_SUCCESSFUL)                      
    goto err_rbar;                                                    
  if (rtems_barrier_create(                                           
 200de1c:	03 14 12 5d 	sethi  %hi(0x50497400), %g1                    
 200de20:	82 10 63 00 	or  %g1, 0x300, %g1	! 50497700 <RAM_END+0x4e097700>
 200de24:	92 10 20 00 	clr  %o1                                       
 200de28:	90 12 00 01 	or  %o0, %g1, %o0                              
 200de2c:	94 10 20 00 	clr  %o2                                       
 200de30:	40 00 05 e7 	call  200f5cc <rtems_barrier_create>           
 200de34:	96 07 60 30 	add  %i5, 0x30, %o3                            
 200de38:	80 a2 20 00 	cmp  %o0, 0                                    
 200de3c:	12 80 00 26 	bne  200ded4 <fifo_open+0x1c8>                 
 200de40:	d0 4f 22 38 	ldsb  [ %i4 + 0x238 ], %o0                     
        rtems_build_name ('P', 'I', 'w', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->writeBarrier) != RTEMS_SUCCESSFUL)                     
    goto err_wbar;                                                    
  if (rtems_semaphore_create(                                         
 200de44:	b4 16 a3 00 	or  %i2, 0x300, %i2                            
 200de48:	92 10 20 01 	mov  1, %o1                                    
 200de4c:	90 12 00 1a 	or  %o0, %i2, %o0                              
 200de50:	94 10 20 10 	mov  0x10, %o2                                 
 200de54:	96 10 20 00 	clr  %o3                                       
 200de58:	7f ff eb a2 	call  2008ce0 <rtems_semaphore_create>         
 200de5c:	98 07 60 28 	add  %i5, 0x28, %o4                            
 200de60:	80 a2 20 00 	cmp  %o0, 0                                    
 200de64:	12 80 00 1a 	bne  200decc <fifo_open+0x1c0>                 
 200de68:	94 07 bf fc 	add  %fp, -4, %o2                              
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (                  
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Barrier_Control *)                                          
 200de6c:	d2 07 60 2c 	ld  [ %i5 + 0x2c ], %o1                        
 200de70:	31 00 80 8f 	sethi  %hi(0x2023c00), %i0                     
 200de74:	7f ff f2 dd 	call  200a9e8 <_Objects_Get>                   
 200de78:	90 16 21 b0 	or  %i0, 0x1b0, %o0	! 2023db0 <_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;                                
 200de7c:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
 200de80:	35 04 00 00 	sethi  %hi(0x10000000), %i2                    
 200de84:	82 10 40 1a 	or  %g1, %i2, %g1                              
  _Thread_Enable_dispatch();                                          
 200de88:	7f ff f6 90 	call  200b8c8 <_Thread_Enable_dispatch>        
 200de8c:	c2 22 20 4c 	st  %g1, [ %o0 + 0x4c ]                        
 200de90:	d2 07 60 30 	ld  [ %i5 + 0x30 ], %o1                        
 200de94:	94 07 bf fc 	add  %fp, -4, %o2                              
 200de98:	7f ff f2 d4 	call  200a9e8 <_Objects_Get>                   
 200de9c:	90 16 21 b0 	or  %i0, 0x1b0, %o0                            
  _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
    |= STATES_INTERRUPTIBLE_BY_SIGNAL;                                
 200dea0:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
 200dea4:	b4 10 40 1a 	or  %g1, %i2, %i2                              
  _Thread_Enable_dispatch();                                          
 200dea8:	7f ff f6 88 	call  200b8c8 <_Thread_Enable_dispatch>        
 200deac:	f4 22 20 4c 	st  %i2, [ %o0 + 0x4c ]                        
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
 200deb0:	c2 0f 22 38 	ldub  [ %i4 + 0x238 ], %g1                     
 200deb4:	c4 4f 22 38 	ldsb  [ %i4 + 0x238 ], %g2                     
 200deb8:	80 a0 a0 7a 	cmp  %g2, 0x7a                                 
 200debc:	12 80 00 a7 	bne  200e158 <fifo_open+0x44c>                 
 200dec0:	82 00 60 01 	inc  %g1                                       
    c = 'a';                                                          
 200dec4:	10 80 00 a5 	b  200e158 <fifo_open+0x44c>                   
 200dec8:	82 10 20 61 	mov  0x61, %g1                                 
  return 0;                                                           
                                                                      
err_sem:                                                              
  rtems_barrier_delete(pipe->writeBarrier);                           
 200decc:	40 00 05 ef 	call  200f688 <rtems_barrier_delete>           
 200ded0:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
err_wbar:                                                             
  rtems_barrier_delete(pipe->readBarrier);                            
 200ded4:	40 00 05 ed 	call  200f688 <rtems_barrier_delete>           
 200ded8:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
err_rbar:                                                             
  free(pipe->Buffer);                                                 
 200dedc:	7f ff da 57 	call  2004838 <free>                           
 200dee0:	d0 07 40 00 	ld  [ %i5 ], %o0                               
err_buf:                                                              
  free(pipe);                                                         
 200dee4:	7f ff da 55 	call  2004838 <free>                           
 200dee8:	90 10 00 1d 	mov  %i5, %o0                                  
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
 200deec:	10 80 00 13 	b  200df38 <fifo_open+0x22c>                   
 200def0:	b0 10 3f f4 	mov  -12, %i0                                  
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
 200def4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 200def8:	92 10 20 00 	clr  %o1                                       
 200defc:	7f ff ec 16 	call  2008f54 <rtems_semaphore_obtain>         
 200df00:	94 10 20 00 	clr  %o2                                       
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
 200df04:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
 200df08:	80 a0 00 08 	cmp  %g0, %o0                                  
 200df0c:	b0 60 20 00 	subx  %g0, 0, %i0                              
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
 200df10:	80 a0 60 00 	cmp  %g1, 0                                    
 200df14:	12 80 00 09 	bne  200df38 <fifo_open+0x22c>                 
 200df18:	b0 0e 3f fc 	and  %i0, -4, %i0                              
    if (err)                                                          
 200df1c:	80 a6 20 00 	cmp  %i0, 0                                    
 200df20:	22 80 00 06 	be,a   200df38 <fifo_open+0x22c>               <== ALWAYS TAKEN
 200df24:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
      pipe_free(pipe);                                                
 200df28:	7f ff ff 41 	call  200dc2c <pipe_free>                      <== NOT EXECUTED
 200df2c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
 200df30:	10 80 00 03 	b  200df3c <fifo_open+0x230>                   <== NOT EXECUTED
 200df34:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     <== NOT EXECUTED
 200df38:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     
 200df3c:	7f ff ec 4f 	call  2009078 <rtems_semaphore_release>        
 200df40:	d0 00 61 80 	ld  [ %g1 + 0x180 ], %o0	! 2023180 <pipe_semaphore>
  pipe_control_t *pipe;                                               
  unsigned int prevCounter;                                           
  int err;                                                            
                                                                      
  err = pipe_new(pipep);                                              
  if (err)                                                            
 200df44:	80 a6 20 00 	cmp  %i0, 0                                    
 200df48:	12 80 00 86 	bne  200e160 <fifo_open+0x454>                 
 200df4c:	01 00 00 00 	nop                                            
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
 200df50:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 200df54:	82 08 60 06 	and  %g1, 6, %g1                               
 200df58:	80 a0 60 04 	cmp  %g1, 4                                    
 200df5c:	02 80 00 2e 	be  200e014 <fifo_open+0x308>                  
 200df60:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
 200df64:	80 a0 60 06 	cmp  %g1, 6                                    
 200df68:	02 80 00 56 	be  200e0c0 <fifo_open+0x3b4>                  
 200df6c:	80 a0 60 02 	cmp  %g1, 2                                    
 200df70:	12 80 00 6a 	bne  200e118 <fifo_open+0x40c>                 <== NEVER TAKEN
 200df74:	01 00 00 00 	nop                                            
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
 200df78:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 200df7c:	82 00 60 01 	inc  %g1                                       
 200df80:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      if (pipe->Readers ++ == 0)                                      
 200df84:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200df88:	84 00 60 01 	add  %g1, 1, %g2                               
 200df8c:	80 a0 60 00 	cmp  %g1, 0                                    
 200df90:	12 80 00 05 	bne  200dfa4 <fifo_open+0x298>                 <== NEVER TAKEN
 200df94:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
        PIPE_WAKEUPWRITERS(pipe);                                     
 200df98:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
 200df9c:	40 00 05 e4 	call  200f72c <rtems_barrier_release>          
 200dfa0:	92 07 bf f8 	add  %fp, -8, %o1                              
                                                                      
      if (pipe->Writers == 0) {                                       
 200dfa4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200dfa8:	80 a0 60 00 	cmp  %g1, 0                                    
 200dfac:	12 80 00 5b 	bne  200e118 <fifo_open+0x40c>                 
 200dfb0:	01 00 00 00 	nop                                            
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
 200dfb4:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 200dfb8:	80 88 60 01 	btst  1, %g1                                   
 200dfbc:	12 80 00 57 	bne  200e118 <fifo_open+0x40c>                 
 200dfc0:	01 00 00 00 	nop                                            
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
 200dfc4:	f8 07 60 24 	ld  [ %i5 + 0x24 ], %i4                        
        err = -EINTR;                                                 
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
 200dfc8:	7f ff ec 2c 	call  2009078 <rtems_semaphore_release>        
 200dfcc:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          if (! PIPE_READWAIT(pipe))                                  
 200dfd0:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
 200dfd4:	40 00 05 ec 	call  200f784 <rtems_barrier_wait>             
 200dfd8:	92 10 20 00 	clr  %o1                                       
 200dfdc:	80 a2 20 00 	cmp  %o0, 0                                    
 200dfe0:	12 80 00 52 	bne  200e128 <fifo_open+0x41c>                 <== NEVER TAKEN
 200dfe4:	92 10 20 00 	clr  %o1                                       
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
 200dfe8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 200dfec:	7f ff eb da 	call  2008f54 <rtems_semaphore_obtain>         
 200dff0:	94 10 20 00 	clr  %o2                                       
 200dff4:	80 a2 20 00 	cmp  %o0, 0                                    
 200dff8:	32 80 00 4d 	bne,a   200e12c <fifo_open+0x420>              <== NEVER TAKEN
 200dffc:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
            goto out_error;                                           
        } while (prevCounter == pipe->writerCounter);                 
 200e000:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 200e004:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e008:	02 bf ff f0 	be  200dfc8 <fifo_open+0x2bc>                  <== NEVER TAKEN
 200e00c:	01 00 00 00 	nop                                            
 200e010:	30 80 00 42 	b,a   200e118 <fifo_open+0x40c>                
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
 200e014:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 200e018:	82 00 60 01 	inc  %g1                                       
 200e01c:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
                                                                      
      if (pipe->Writers ++ == 0)                                      
 200e020:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200e024:	84 00 60 01 	add  %g1, 1, %g2                               
 200e028:	80 a0 60 00 	cmp  %g1, 0                                    
 200e02c:	12 80 00 05 	bne  200e040 <fifo_open+0x334>                 <== NEVER TAKEN
 200e030:	c4 27 60 14 	st  %g2, [ %i5 + 0x14 ]                        
        PIPE_WAKEUPREADERS(pipe);                                     
 200e034:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
 200e038:	40 00 05 bd 	call  200f72c <rtems_barrier_release>          
 200e03c:	92 07 bf f8 	add  %fp, -8, %o1                              
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
 200e040:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200e044:	80 a0 60 00 	cmp  %g1, 0                                    
 200e048:	12 80 00 34 	bne  200e118 <fifo_open+0x40c>                 
 200e04c:	01 00 00 00 	nop                                            
 200e050:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 200e054:	80 88 60 01 	btst  1, %g1                                   
 200e058:	22 80 00 07 	be,a   200e074 <fifo_open+0x368>               
 200e05c:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        
	PIPE_UNLOCK(pipe);                                                   
 200e060:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 200e064:	7f ff ec 05 	call  2009078 <rtems_semaphore_release>        
 200e068:	b0 10 3f fa 	mov  -6, %i0                                   
        err = -ENXIO;                                                 
        goto out_error;                                               
 200e06c:	10 80 00 31 	b  200e130 <fifo_open+0x424>                   
 200e070:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
 200e074:	7f ff ec 01 	call  2009078 <rtems_semaphore_release>        
 200e078:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          if (! PIPE_WRITEWAIT(pipe))                                 
 200e07c:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
 200e080:	40 00 05 c1 	call  200f784 <rtems_barrier_wait>             
 200e084:	92 10 20 00 	clr  %o1                                       
 200e088:	80 a2 20 00 	cmp  %o0, 0                                    
 200e08c:	12 80 00 27 	bne  200e128 <fifo_open+0x41c>                 <== NEVER TAKEN
 200e090:	92 10 20 00 	clr  %o1                                       
            goto out_error;                                           
          if (! PIPE_LOCK(pipe))                                      
 200e094:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 200e098:	7f ff eb af 	call  2008f54 <rtems_semaphore_obtain>         
 200e09c:	94 10 20 00 	clr  %o2                                       
 200e0a0:	80 a2 20 00 	cmp  %o0, 0                                    
 200e0a4:	32 80 00 22 	bne,a   200e12c <fifo_open+0x420>              <== NEVER TAKEN
 200e0a8:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
            goto out_error;                                           
        } while (prevCounter == pipe->readerCounter);                 
 200e0ac:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 200e0b0:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e0b4:	02 bf ff f0 	be  200e074 <fifo_open+0x368>                  <== NEVER TAKEN
 200e0b8:	01 00 00 00 	nop                                            
 200e0bc:	30 80 00 17 	b,a   200e118 <fifo_open+0x40c>                
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
 200e0c0:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 200e0c4:	82 00 60 01 	inc  %g1                                       
 200e0c8:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      if (pipe->Readers ++ == 0)                                      
 200e0cc:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200e0d0:	84 00 60 01 	add  %g1, 1, %g2                               
 200e0d4:	80 a0 60 00 	cmp  %g1, 0                                    
 200e0d8:	12 80 00 05 	bne  200e0ec <fifo_open+0x3e0>                 <== NEVER TAKEN
 200e0dc:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
        PIPE_WAKEUPWRITERS(pipe);                                     
 200e0e0:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
 200e0e4:	40 00 05 92 	call  200f72c <rtems_barrier_release>          
 200e0e8:	92 07 bf f8 	add  %fp, -8, %o1                              
      pipe->writerCounter ++;                                         
 200e0ec:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 200e0f0:	82 00 60 01 	inc  %g1                                       
 200e0f4:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
      if (pipe->Writers ++ == 0)                                      
 200e0f8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200e0fc:	84 00 60 01 	add  %g1, 1, %g2                               
 200e100:	80 a0 60 00 	cmp  %g1, 0                                    
 200e104:	12 80 00 05 	bne  200e118 <fifo_open+0x40c>                 <== NEVER TAKEN
 200e108:	c4 27 60 14 	st  %g2, [ %i5 + 0x14 ]                        
        PIPE_WAKEUPREADERS(pipe);                                     
 200e10c:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
 200e110:	40 00 05 87 	call  200f72c <rtems_barrier_release>          
 200e114:	92 07 bf f8 	add  %fp, -8, %o1                              
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
 200e118:	7f ff eb d8 	call  2009078 <rtems_semaphore_release>        
 200e11c:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
  return 0;                                                           
 200e120:	81 c7 e0 08 	ret                                            
 200e124:	81 e8 00 00 	restore                                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
 200e128:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
 200e12c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
 200e130:	7f ff fe ca 	call  200dc58 <pipe_release>                   
 200e134:	92 10 00 19 	mov  %i1, %o1                                  
  return err;                                                         
 200e138:	81 c7 e0 08 	ret                                            
 200e13c:	81 e8 00 00 	restore                                        
  err = pipe_lock();                                                  
  if (err)                                                            
    return err;                                                       
                                                                      
  pipe = *pipep;                                                      
  if (pipe == NULL) {                                                 
 200e140:	80 a7 60 00 	cmp  %i5, 0                                    
 200e144:	32 bf ff 6d 	bne,a   200def8 <fifo_open+0x1ec>              
 200e148:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 200e14c:	30 bf ff 1a 	b,a   200ddb4 <fifo_open+0xa8>                 
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
 200e150:	10 bf ff 7a 	b  200df38 <fifo_open+0x22c>                   <== NOT EXECUTED
 200e154:	b0 10 3f f4 	mov  -12, %i0                                  <== NOT EXECUTED
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
 200e158:	10 bf ff 67 	b  200def4 <fifo_open+0x1e8>                   
 200e15c:	c2 2f 22 38 	stb  %g1, [ %i4 + 0x238 ]                      
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
  return err;                                                         
}                                                                     
 200e160:	81 c7 e0 08 	ret                                            
 200e164:	81 e8 00 00 	restore                                        
                                                                      

02009608 <fpathconf>: */ long fpathconf( int fd, int name ) {
 2009608:	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);                                           
 200960c:	03 00 80 48 	sethi  %hi(0x2012000), %g1                     
 2009610:	c2 00 61 c8 	ld  [ %g1 + 0x1c8 ], %g1	! 20121c8 <rtems_libio_number_iops>
 2009614:	80 a6 00 01 	cmp  %i0, %g1                                  
 2009618:	2a 80 00 03 	bcs,a   2009624 <fpathconf+0x1c>               
 200961c:	83 2e 20 03 	sll  %i0, 3, %g1                               
 2009620:	30 80 00 0a 	b,a   2009648 <fpathconf+0x40>                 
  iop = rtems_libio_iop(fd);                                          
 2009624:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2009628:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 200962c:	03 00 80 4a 	sethi  %hi(0x2012800), %g1                     
 2009630:	c2 00 61 f0 	ld  [ %g1 + 0x1f0 ], %g1	! 20129f0 <rtems_libio_iops>
 2009634:	b0 00 40 18 	add  %g1, %i0, %i0                             
  rtems_libio_check_is_open(iop);                                     
 2009638:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
 200963c:	80 88 61 00 	btst  0x100, %g1                               
 2009640:	32 80 00 06 	bne,a   2009658 <fpathconf+0x50>               <== ALWAYS TAKEN
 2009644:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
 2009648:	40 00 08 f5 	call  200ba1c <__errno>                        
 200964c:	01 00 00 00 	nop                                            
 2009650:	10 80 00 32 	b  2009718 <fpathconf+0x110>                   
 2009654:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;   
                                                                      
  switch ( name ) {                                                   
 2009658:	80 a6 60 0b 	cmp  %i1, 0xb                                  
 200965c:	18 80 00 2c 	bgu  200970c <fpathconf+0x104>                 
 2009660:	c2 00 60 2c 	ld  [ %g1 + 0x2c ], %g1                        
 2009664:	b3 2e 60 02 	sll  %i1, 2, %i1                               
 2009668:	05 00 80 25 	sethi  %hi(0x2009400), %g2                     
 200966c:	84 10 a1 d8 	or  %g2, 0x1d8, %g2	! 20095d8 <_close_r+0x10>  
 2009670:	c4 00 80 19 	ld  [ %g2 + %i1 ], %g2                         
 2009674:	81 c0 80 00 	jmp  %g2                                       
 2009678:	01 00 00 00 	nop                                            
    case _PC_LINK_MAX:                                                
      return_value = the_limits->link_max;                            
 200967c:	f0 00 40 00 	ld  [ %g1 ], %i0                               
      break;                                                          
 2009680:	81 c7 e0 08 	ret                                            
 2009684:	81 e8 00 00 	restore                                        
    case _PC_MAX_CANON:                                               
      return_value = the_limits->max_canon;                           
 2009688:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
      break;                                                          
 200968c:	81 c7 e0 08 	ret                                            
 2009690:	81 e8 00 00 	restore                                        
    case _PC_MAX_INPUT:                                               
      return_value = the_limits->max_input;                           
 2009694:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
      break;                                                          
 2009698:	81 c7 e0 08 	ret                                            
 200969c:	81 e8 00 00 	restore                                        
    case _PC_NAME_MAX:                                                
      return_value = the_limits->name_max;                            
 20096a0:	f0 00 60 0c 	ld  [ %g1 + 0xc ], %i0                         
      break;                                                          
 20096a4:	81 c7 e0 08 	ret                                            
 20096a8:	81 e8 00 00 	restore                                        
    case _PC_PATH_MAX:                                                
      return_value = the_limits->path_max;                            
 20096ac:	f0 00 60 10 	ld  [ %g1 + 0x10 ], %i0                        
      break;                                                          
 20096b0:	81 c7 e0 08 	ret                                            
 20096b4:	81 e8 00 00 	restore                                        
    case _PC_PIPE_BUF:                                                
      return_value = the_limits->pipe_buf;                            
 20096b8:	f0 00 60 14 	ld  [ %g1 + 0x14 ], %i0                        
      break;                                                          
 20096bc:	81 c7 e0 08 	ret                                            
 20096c0:	81 e8 00 00 	restore                                        
    case _PC_CHOWN_RESTRICTED:                                        
      return_value = the_limits->posix_chown_restrictions;            
 20096c4:	f0 00 60 1c 	ld  [ %g1 + 0x1c ], %i0                        
      break;                                                          
 20096c8:	81 c7 e0 08 	ret                                            
 20096cc:	81 e8 00 00 	restore                                        
    case _PC_NO_TRUNC:                                                
      return_value = the_limits->posix_no_trunc;                      
 20096d0:	f0 00 60 20 	ld  [ %g1 + 0x20 ], %i0                        
      break;                                                          
 20096d4:	81 c7 e0 08 	ret                                            
 20096d8:	81 e8 00 00 	restore                                        
    case _PC_VDISABLE:                                                
      return_value = the_limits->posix_vdisable;                      
 20096dc:	f0 00 60 2c 	ld  [ %g1 + 0x2c ], %i0                        
      break;                                                          
 20096e0:	81 c7 e0 08 	ret                                            
 20096e4:	81 e8 00 00 	restore                                        
    case _PC_ASYNC_IO:                                                
      return_value = the_limits->posix_async_io;                      
 20096e8:	f0 00 60 18 	ld  [ %g1 + 0x18 ], %i0                        
      break;                                                          
 20096ec:	81 c7 e0 08 	ret                                            
 20096f0:	81 e8 00 00 	restore                                        
    case _PC_PRIO_IO:                                                 
      return_value = the_limits->posix_prio_io;                       
 20096f4:	f0 00 60 24 	ld  [ %g1 + 0x24 ], %i0                        
      break;                                                          
 20096f8:	81 c7 e0 08 	ret                                            
 20096fc:	81 e8 00 00 	restore                                        
    case _PC_SYNC_IO:                                                 
      return_value = the_limits->posix_sync_io;                       
 2009700:	f0 00 60 28 	ld  [ %g1 + 0x28 ], %i0                        
      break;                                                          
 2009704:	81 c7 e0 08 	ret                                            
 2009708:	81 e8 00 00 	restore                                        
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
 200970c:	40 00 08 c4 	call  200ba1c <__errno>                        
 2009710:	01 00 00 00 	nop                                            
 2009714:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2009718:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      break;                                                          
  }                                                                   
                                                                      
  return return_value;                                                
}                                                                     
 200971c:	81 c7 e0 08 	ret                                            
 2009720:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

020035b0 <free>: #include <stdlib.h> void free( void *ptr ) {
 20035b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  MSBUMP(free_calls, 1);                                              
 20035b4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20035b8:	82 10 60 50 	or  %g1, 0x50, %g1	! 201d450 <rtems_malloc_statistics>
 20035bc:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
#include <stdlib.h>                                                   
                                                                      
void free(                                                            
  void *ptr                                                           
)                                                                     
{                                                                     
 20035c0:	b2 10 00 18 	mov  %i0, %i1                                  
  MSBUMP(free_calls, 1);                                              
 20035c4:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if ( !ptr )                                                         
 20035c8:	80 a6 20 00 	cmp  %i0, 0                                    
 20035cc:	02 80 00 21 	be  2003650 <free+0xa0>                        
 20035d0:	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()) &&                    
 20035d4:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 20035d8:	c2 00 62 e8 	ld  [ %g1 + 0x2e8 ], %g1	! 201dae8 <_System_state_Current>
 20035dc:	80 a0 60 03 	cmp  %g1, 3                                    
 20035e0:	12 80 00 09 	bne  2003604 <free+0x54>                       <== NEVER TAKEN
 20035e4:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
       !malloc_is_system_state_OK() ) {                               
 20035e8:	40 00 00 78 	call  20037c8 <malloc_is_system_state_OK>      
 20035ec:	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()) &&                    
 20035f0:	80 8a 20 ff 	btst  0xff, %o0                                
 20035f4:	12 80 00 04 	bne  2003604 <free+0x54>                       
 20035f8:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
 20035fc:	40 00 00 8c 	call  200382c <malloc_deferred_free>           
 2003600:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
 2003604:	c2 00 61 90 	ld  [ %g1 + 0x190 ], %g1                       
 2003608:	80 a0 60 00 	cmp  %g1, 0                                    
 200360c:	02 80 00 06 	be  2003624 <free+0x74>                        
 2003610:	3b 00 80 72 	sethi  %hi(0x201c800), %i5                     
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
 2003614:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 2003618:	9f c0 40 00 	call  %g1                                      
 200361c:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
 2003620:	3b 00 80 72 	sethi  %hi(0x201c800), %i5                     
 2003624:	d0 07 61 b0 	ld  [ %i5 + 0x1b0 ], %o0	! 201c9b0 <RTEMS_Malloc_Heap>
 2003628:	40 00 17 72 	call  20093f0 <_Protected_heap_Free>           
 200362c:	92 10 00 19 	mov  %i1, %o1                                  
 2003630:	80 8a 20 ff 	btst  0xff, %o0                                
 2003634:	12 80 00 07 	bne  2003650 <free+0xa0>                       
 2003638:	c2 07 61 b0 	ld  [ %i5 + 0x1b0 ], %g1                       
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
 200363c:	31 00 80 6c 	sethi  %hi(0x201b000), %i0                     
 2003640:	f4 00 60 18 	ld  [ %g1 + 0x18 ], %i2                        
 2003644:	f6 00 60 1c 	ld  [ %g1 + 0x1c ], %i3                        
 2003648:	40 00 03 68 	call  20043e8 <printk>                         
 200364c:	91 ee 23 08 	restore  %i0, 0x308, %o0                       
 2003650:	81 c7 e0 08 	ret                                            
 2003654:	81 e8 00 00 	restore                                        
                                                                      

02019c8c <fstat>: int fstat( int fd, struct stat *sbuf ) {
 2019c8c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
  if ( !sbuf )                                                        
 2019c90:	80 a6 60 00 	cmp  %i1, 0                                    
 2019c94:	32 80 00 06 	bne,a   2019cac <fstat+0x20>                   <== ALWAYS TAKEN
 2019c98:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
    rtems_set_errno_and_return_minus_one( EFAULT );                   
 2019c9c:	7f ff d6 74 	call  200f66c <__errno>                        <== NOT EXECUTED
 2019ca0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2019ca4:	10 80 00 12 	b  2019cec <fstat+0x60>                        <== NOT EXECUTED
 2019ca8:	82 10 20 0e 	mov  0xe, %g1	! e <PROM_START+0xe>             <== NOT EXECUTED
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
 2019cac:	c2 00 61 f4 	ld  [ %g1 + 0x1f4 ], %g1                       
 2019cb0:	80 a6 00 01 	cmp  %i0, %g1                                  
 2019cb4:	1a 80 00 0b 	bcc  2019ce0 <fstat+0x54>                      
 2019cb8:	83 2e 20 03 	sll  %i0, 3, %g1                               
 2019cbc:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2019cc0:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2019cc4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2019cc8:	c2 00 60 44 	ld  [ %g1 + 0x44 ], %g1	! 201d444 <rtems_libio_iops>
 2019ccc:	b0 00 40 18 	add  %g1, %i0, %i0                             
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
 2019cd0:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
 2019cd4:	80 88 61 00 	btst  0x100, %g1                               
 2019cd8:	12 80 00 08 	bne  2019cf8 <fstat+0x6c>                      
 2019cdc:	94 10 20 48 	mov  0x48, %o2                                 
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
  rtems_libio_check_fd( fd );                                         
 2019ce0:	7f ff d6 63 	call  200f66c <__errno>                        
 2019ce4:	01 00 00 00 	nop                                            
 2019ce8:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
 2019cec:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2019cf0:	81 c7 e0 08 	ret                                            
 2019cf4:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      
  /*                                                                  
   *  Zero out the stat structure so the various support              
   *  versions of stat don't have to.                                 
   */                                                                 
  memset( sbuf, 0, sizeof(struct stat) );                             
 2019cf8:	90 10 00 19 	mov  %i1, %o0                                  
 2019cfc:	7f ff d8 ea 	call  20100a4 <memset>                         
 2019d00:	92 10 20 00 	clr  %o1                                       
                                                                      
  return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );  
 2019d04:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 2019d08:	90 06 20 14 	add  %i0, 0x14, %o0                            
 2019d0c:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
 2019d10:	9f c0 40 00 	call  %g1                                      
 2019d14:	92 10 00 19 	mov  %i1, %o1                                  
}                                                                     
 2019d18:	81 c7 e0 08 	ret                                            
 2019d1c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020034c8 <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) {
 20034c8:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 20034cc:	c2 00 61 30 	ld  [ %g1 + 0x130 ], %g1	! 2021530 <disktab_size>
 20034d0:	80 a2 00 01 	cmp  %o0, %g1                                  
 20034d4:	1a 80 00 1e 	bcc  200354c <get_disk_entry+0x84>             <== NEVER TAKEN
 20034d8:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 20034dc:	c2 00 61 34 	ld  [ %g1 + 0x134 ], %g1	! 2021534 <disktab>   
 20034e0:	80 a0 60 00 	cmp  %g1, 0                                    
 20034e4:	22 80 00 1b 	be,a   2003550 <get_disk_entry+0x88>           <== NEVER TAKEN
 20034e8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    rtems_disk_device_table *dtab = disktab + major;                  
 20034ec:	91 2a 20 03 	sll  %o0, 3, %o0                               
 20034f0:	84 00 40 08 	add  %g1, %o0, %g2                             
                                                                      
    if (minor < dtab->size && dtab->minor != NULL) {                  
 20034f4:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
 20034f8:	80 a2 40 02 	cmp  %o1, %g2                                  
 20034fc:	3a 80 00 15 	bcc,a   2003550 <get_disk_entry+0x88>          <== NEVER TAKEN
 2003500:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 2003504:	c2 00 40 08 	ld  [ %g1 + %o0 ], %g1                         
 2003508:	80 a0 60 00 	cmp  %g1, 0                                    
 200350c:	02 80 00 10 	be  200354c <get_disk_entry+0x84>              <== NEVER TAKEN
 2003510:	93 2a 60 02 	sll  %o1, 2, %o1                               
      rtems_disk_device *dd = dtab->minor [minor];                    
                                                                      
      if (dd != NULL && !lookup_only) {                               
 2003514:	80 a2 a0 01 	cmp  %o2, 1                                    
 2003518:	02 80 00 0e 	be  2003550 <get_disk_entry+0x88>              
 200351c:	d0 00 40 09 	ld  [ %g1 + %o1 ], %o0                         
 2003520:	80 a2 20 00 	cmp  %o0, 0                                    
 2003524:	02 80 00 0b 	be  2003550 <get_disk_entry+0x88>              <== NEVER TAKEN
 2003528:	01 00 00 00 	nop                                            
        if (!dd->deleted) {                                           
 200352c:	c2 0a 20 40 	ldub  [ %o0 + 0x40 ], %g1                      
 2003530:	80 a0 60 00 	cmp  %g1, 0                                    
 2003534:	32 80 00 07 	bne,a   2003550 <get_disk_entry+0x88>          
 2003538:	90 10 20 00 	clr  %o0                                       
          ++dd->uses;                                                 
 200353c:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
 2003540:	82 00 60 01 	inc  %g1                                       
 2003544:	81 c3 e0 08 	retl                                           
 2003548:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
                                                                      
      return dd;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return NULL;                                                        
 200354c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
}                                                                     
 2003550:	81 c3 e0 08 	retl                                           
                                                                      

020048b4 <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,
 20048b4:	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);
 20048b8:	40 00 05 85 	call  2005ecc <malloc>                         
 20048bc:	90 10 22 04 	mov  0x204, %o0                                
    if (s == NULL)                                                    
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
 20048c0:	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)                                                    
 20048c4:	80 a2 20 00 	cmp  %o0, 0                                    
 20048c8:	02 80 00 0f 	be  2004904 <get_sector.part.0+0x50>           <== NEVER TAKEN
 20048cc:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);                     
 20048d0:	90 10 00 18 	mov  %i0, %o0                                  
 20048d4:	92 07 60 04 	add  %i5, 4, %o1                               
 20048d8:	40 00 08 43 	call  20069e4 <read>                           
 20048dc:	94 10 22 00 	mov  0x200, %o2                                
    if (n != RTEMS_IDE_SECTOR_SIZE)                                   
 20048e0:	80 a2 22 00 	cmp  %o0, 0x200                                
 20048e4:	22 80 00 06 	be,a   20048fc <get_sector.part.0+0x48>        <== ALWAYS TAKEN
 20048e8:	f2 27 40 00 	st  %i1, [ %i5 ]                               
    {                                                                 
        free(s);                                                      
 20048ec:	40 00 03 e7 	call  2005888 <free>                           <== NOT EXECUTED
 20048f0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        return RTEMS_IO_ERROR;                                        
 20048f4:	10 80 00 04 	b  2004904 <get_sector.part.0+0x50>            <== NOT EXECUTED
 20048f8:	82 10 20 1b 	mov  0x1b, %g1                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    s->sector_num = sector_num;                                       
                                                                      
    *sector = s;                                                      
 20048fc:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
    return RTEMS_SUCCESSFUL;                                          
 2004900:	82 10 20 00 	clr  %g1                                       
}                                                                     
 2004904:	81 c7 e0 08 	ret                                            
 2004908:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0202f964 <getdents>: int getdents( int dd_fd, char *dd_buf, int dd_len ) {
 202f964:	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 );                                     
 202f968:	03 00 80 d7 	sethi  %hi(0x2035c00), %g1                     
 202f96c:	c2 00 60 8c 	ld  [ %g1 + 0x8c ], %g1	! 2035c8c <rtems_libio_number_iops>
 202f970:	80 a6 00 01 	cmp  %i0, %g1                                  
 202f974:	1a 80 00 08 	bcc  202f994 <getdents+0x30>                   <== NEVER TAKEN
 202f978:	ba 10 20 00 	clr  %i5                                       
 202f97c:	83 2e 20 03 	sll  %i0, 3, %g1                               
 202f980:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 202f984:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 202f988:	03 00 81 1a 	sethi  %hi(0x2046800), %g1                     
 202f98c:	fa 00 60 38 	ld  [ %g1 + 0x38 ], %i5	! 2046838 <rtems_libio_iops>
 202f990:	ba 07 40 18 	add  %i5, %i0, %i5                             
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  type = rtems_filesystem_node_type( &iop->pathinfo );                
 202f994:	7f ff 69 64 	call  2009f24 <rtems_filesystem_node_type>     
 202f998:	90 07 60 14 	add  %i5, 0x14, %o0                            
  if ( type != RTEMS_FILESYSTEM_DIRECTORY )                           
 202f99c:	80 a2 20 00 	cmp  %o0, 0                                    
 202f9a0:	22 80 00 08 	be,a   202f9c0 <getdents+0x5c>                 
 202f9a4:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
    rtems_set_errno_and_return_minus_one( ENOTDIR );                  
 202f9a8:	7f ff c4 1e 	call  2020a20 <__errno>                        
 202f9ac:	b0 10 3f ff 	mov  -1, %i0                                   
 202f9b0:	82 10 20 14 	mov  0x14, %g1                                 
 202f9b4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 202f9b8:	81 c7 e0 08 	ret                                            
 202f9bc:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  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  );   
 202f9c0:	90 10 00 1d 	mov  %i5, %o0                                  
 202f9c4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 202f9c8:	92 10 00 19 	mov  %i1, %o1                                  
 202f9cc:	9f c0 40 00 	call  %g1                                      
 202f9d0:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
 202f9d4:	81 c7 e0 08 	ret                                            
 202f9d8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020242d0 <init_etc_passwd_group>: /** * Initialize useable but dummy databases */ void init_etc_passwd_group(void) {
 20242d0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
 20242d4:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 20242d8:	c4 48 60 c0 	ldsb  [ %g1 + 0xc0 ], %g2	! 20618c0 <etc_passwd_initted.7073>
 20242dc:	80 a0 a0 00 	cmp  %g2, 0                                    
 20242e0:	12 80 00 2f 	bne  202439c <init_etc_passwd_group+0xcc>      
 20242e4:	84 10 20 01 	mov  1, %g2                                    
    return;                                                           
  etc_passwd_initted = 1;                                             
  mkdir("/etc", 0777);                                                
 20242e8:	92 10 21 ff 	mov  0x1ff, %o1                                
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
    return;                                                           
  etc_passwd_initted = 1;                                             
 20242ec:	c4 28 60 c0 	stb  %g2, [ %g1 + 0xc0 ]                       
  mkdir("/etc", 0777);                                                
 20242f0:	11 00 81 63 	sethi  %hi(0x2058c00), %o0                     
 20242f4:	7f ff 7d 25 	call  2003788 <mkdir>                          
 20242f8:	90 12 20 28 	or  %o0, 0x28, %o0	! 2058c28 <RTEMS_BDPART_MBR_MASTER_TYPE+0x6f8>
                                                                      
  /*                                                                  
   *  Initialize /etc/passwd                                          
   */                                                                 
  if ((fp = fopen("/etc/passwd", "r")) != NULL) {                     
 20242fc:	3b 00 81 63 	sethi  %hi(0x2058c00), %i5                     
 2024300:	13 00 81 75 	sethi  %hi(0x205d400), %o1                     
 2024304:	90 17 60 30 	or  %i5, 0x30, %o0                             
 2024308:	40 00 4c 83 	call  2037514 <fopen>                          
 202430c:	92 12 61 38 	or  %o1, 0x138, %o1                            
 2024310:	80 a2 20 00 	cmp  %o0, 0                                    
 2024314:	22 80 00 03 	be,a   2024320 <init_etc_passwd_group+0x50>    
 2024318:	90 17 60 30 	or  %i5, 0x30, %o0                             
 202431c:	30 80 00 0b 	b,a   2024348 <init_etc_passwd_group+0x78>     
    fclose(fp);                                                       
  }                                                                   
  else if ((fp = fopen("/etc/passwd", "w")) != NULL) {                
 2024320:	13 00 81 5a 	sethi  %hi(0x2056800), %o1                     
 2024324:	40 00 4c 7c 	call  2037514 <fopen>                          
 2024328:	92 12 63 e0 	or  %o1, 0x3e0, %o1	! 2056be0 <rtems_rtc_shell_usage+0x4e8>
 202432c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2024330:	02 80 00 08 	be  2024350 <init_etc_passwd_group+0x80>       <== NEVER TAKEN
 2024334:	11 00 81 63 	sethi  %hi(0x2058c00), %o0                     
    fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"                        
 2024338:	92 10 00 1d 	mov  %i5, %o1                                  
 202433c:	40 00 4c d9 	call  20376a0 <fputs>                          
 2024340:	90 12 20 40 	or  %o0, 0x40, %o0                             
                 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n"         
                 "tty:!:2:2:tty owner::/:/bin/false\n" );             
    fclose(fp);                                                       
 2024344:	90 10 00 1d 	mov  %i5, %o0                                  
 2024348:	40 00 4a 15 	call  2036b9c <fclose>                         
 202434c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Initialize /etc/group                                           
   */                                                                 
  if ((fp = fopen("/etc/group", "r")) != NULL) {                      
 2024350:	3b 00 81 63 	sethi  %hi(0x2058c00), %i5                     
 2024354:	13 00 81 75 	sethi  %hi(0x205d400), %o1                     
 2024358:	90 17 60 a8 	or  %i5, 0xa8, %o0                             
 202435c:	40 00 4c 6e 	call  2037514 <fopen>                          
 2024360:	92 12 61 38 	or  %o1, 0x138, %o1                            
 2024364:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2024368:	12 80 00 0b 	bne  2024394 <init_etc_passwd_group+0xc4>      
 202436c:	90 17 60 a8 	or  %i5, 0xa8, %o0                             
    fclose(fp);                                                       
  }                                                                   
  else if ((fp = fopen("/etc/group", "w")) != NULL) {                 
 2024370:	13 00 81 5a 	sethi  %hi(0x2056800), %o1                     
 2024374:	40 00 4c 68 	call  2037514 <fopen>                          
 2024378:	92 12 63 e0 	or  %o1, 0x3e0, %o1	! 2056be0 <rtems_rtc_shell_usage+0x4e8>
 202437c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2024380:	02 80 00 07 	be  202439c <init_etc_passwd_group+0xcc>       <== NEVER TAKEN
 2024384:	11 00 81 63 	sethi  %hi(0x2058c00), %o0                     
    fprintf( fp, "root:x:0:root\n"                                    
 2024388:	92 10 00 18 	mov  %i0, %o1                                  
 202438c:	40 00 4c c5 	call  20376a0 <fputs>                          
 2024390:	90 12 20 b8 	or  %o0, 0xb8, %o0                             
                 "rtems:x:1:rtems\n"                                  
                 "tty:x:2:tty\n" );                                   
    fclose(fp);                                                       
 2024394:	40 00 4a 02 	call  2036b9c <fclose>                         
 2024398:	81 e8 00 00 	restore                                        
 202439c:	81 c7 e0 08 	ret                                            
 20243a0:	81 e8 00 00 	restore                                        
                                                                      

0200614c <iproc>: /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) {
 200614c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (tty->termios.c_iflag & ISTRIP)                                  
 2006150:	c2 06 60 30 	ld  [ %i1 + 0x30 ], %g1                        
 2006154:	80 88 60 20 	btst  0x20, %g1                                
 2006158:	32 80 00 02 	bne,a   2006160 <iproc+0x14>                   <== NEVER TAKEN
 200615c:	b0 0e 20 7f 	and  %i0, 0x7f, %i0                            <== NOT EXECUTED
    c &= 0x7f;                                                        
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
 2006160:	80 88 62 00 	btst  0x200, %g1                               
 2006164:	02 80 00 0c 	be  2006194 <iproc+0x48>                       
 2006168:	80 a6 20 0d 	cmp  %i0, 0xd                                  
    c = tolower (c);                                                  
 200616c:	05 00 80 73 	sethi  %hi(0x201cc00), %g2                     
 2006170:	c4 00 a0 58 	ld  [ %g2 + 0x58 ], %g2	! 201cc58 <__ctype_ptr__>
 2006174:	84 00 80 18 	add  %g2, %i0, %g2                             
 2006178:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
 200617c:	84 08 a0 03 	and  %g2, 3, %g2                               
 2006180:	80 a0 a0 01 	cmp  %g2, 1                                    
 2006184:	22 80 00 02 	be,a   200618c <iproc+0x40>                    
 2006188:	b0 06 20 20 	add  %i0, 0x20, %i0                            
 200618c:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
                                                                      
  if (c == '\r') {                                                    
 2006190:	80 a6 20 0d 	cmp  %i0, 0xd                                  
 2006194:	12 80 00 0b 	bne  20061c0 <iproc+0x74>                      
 2006198:	80 a6 20 0a 	cmp  %i0, 0xa                                  
    if (tty->termios.c_iflag & IGNCR)                                 
 200619c:	80 88 60 80 	btst  0x80, %g1                                
 20061a0:	02 80 00 04 	be  20061b0 <iproc+0x64>                       <== ALWAYS TAKEN
 20061a4:	80 88 61 00 	btst  0x100, %g1                               
  if (tty->ccount < (CBUFSIZE-1)) {                                   
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
  }                                                                   
  return 0;                                                           
 20061a8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20061ac:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
    c = tolower (c);                                                  
                                                                      
  if (c == '\r') {                                                    
    if (tty->termios.c_iflag & IGNCR)                                 
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
 20061b0:	32 80 00 0d 	bne,a   20061e4 <iproc+0x98>                   <== ALWAYS TAKEN
 20061b4:	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)) {               
 20061b8:	10 80 00 0c 	b  20061e8 <iproc+0x9c>                        <== NOT EXECUTED
 20061bc:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        <== 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)) {         
 20061c0:	12 80 00 07 	bne  20061dc <iproc+0x90>                      
 20061c4:	80 a6 20 00 	cmp  %i0, 0                                    
 20061c8:	80 88 60 40 	btst  0x40, %g1                                
 20061cc:	32 80 00 06 	bne,a   20061e4 <iproc+0x98>                   <== NEVER TAKEN
 20061d0:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
 20061d4:	10 80 00 05 	b  20061e8 <iproc+0x9c>                        
 20061d8:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
 20061dc:	02 80 00 51 	be  2006320 <iproc+0x1d4>                      <== NEVER TAKEN
 20061e0:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 20061e4:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
 20061e8:	80 88 60 02 	btst  2, %g1                                   
 20061ec:	22 80 00 4d 	be,a   2006320 <iproc+0x1d4>                   
 20061f0:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
    if (c == tty->termios.c_cc[VERASE]) {                             
 20061f4:	c4 0e 60 43 	ldub  [ %i1 + 0x43 ], %g2                      
 20061f8:	80 a0 80 18 	cmp  %g2, %i0                                  
 20061fc:	32 80 00 08 	bne,a   200621c <iproc+0xd0>                   
 2006200:	c4 0e 60 44 	ldub  [ %i1 + 0x44 ], %g2                      
 * FIXME: Some of the tests should check for IEXTEN, too.             
 */                                                                   
static void                                                           
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
  if (tty->ccount == 0)                                               
 2006204:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 2006208:	80 a0 60 00 	cmp  %g1, 0                                    
 200620c:	02 80 00 57 	be  2006368 <iproc+0x21c>                      
 2006210:	90 10 00 19 	mov  %i1, %o0                                  
 2006214:	10 80 00 1d 	b  2006288 <iproc+0x13c>                       
 2006218:	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;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
 200621c:	80 a0 80 18 	cmp  %g2, %i0                                  
 2006220:	32 80 00 1d 	bne,a   2006294 <iproc+0x148>                  
 2006224:	c4 0e 60 45 	ldub  [ %i1 + 0x45 ], %g2                      
 * FIXME: Some of the tests should check for IEXTEN, too.             
 */                                                                   
static void                                                           
erase (struct rtems_termios_tty *tty, int lineFlag)                   
{                                                                     
  if (tty->ccount == 0)                                               
 2006228:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
 200622c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2006230:	02 80 00 4e 	be  2006368 <iproc+0x21c>                      <== NEVER TAKEN
 2006234:	80 88 60 08 	btst  8, %g1                                   
    return;                                                           
  if (lineFlag) {                                                     
    if (!(tty->termios.c_lflag & ECHO)) {                             
 2006238:	12 80 00 04 	bne  2006248 <iproc+0xfc>                      <== ALWAYS TAKEN
 200623c:	90 10 00 19 	mov  %i1, %o0                                  
      tty->ccount = 0;                                                
 2006240:	10 80 00 4a 	b  2006368 <iproc+0x21c>                       <== NOT EXECUTED
 2006244:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
      return;                                                         
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
 2006248:	80 88 60 10 	btst  0x10, %g1                                
 200624c:	12 80 00 0f 	bne  2006288 <iproc+0x13c>                     <== ALWAYS TAKEN
 2006250:	92 10 20 01 	mov  1, %o1                                    
      tty->ccount = 0;                                                
 2006254:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
      echo (tty->termios.c_cc[VKILL], tty);                           
 2006258:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200625c:	7f ff ff 2d 	call  2005f10 <echo>                           <== NOT EXECUTED
 2006260:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
      if (tty->termios.c_lflag & ECHOK)                               
 2006264:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        <== NOT EXECUTED
 2006268:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
 200626c:	22 80 00 42 	be,a   2006374 <iproc+0x228>                   <== NOT EXECUTED
 2006270:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
        echo ('\n', tty);                                             
 2006274:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
 2006278:	7f ff ff 26 	call  2005f10 <echo>                           <== NOT EXECUTED
 200627c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
  if (tty->ccount < (CBUFSIZE-1)) {                                   
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
  }                                                                   
  return 0;                                                           
 2006280:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2006284:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
 2006288:	7f ff ff 43 	call  2005f94 <erase.part.2>                   
 200628c:	b0 10 20 00 	clr  %i0                                       
 2006290:	30 80 00 39 	b,a   2006374 <iproc+0x228>                    
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
      erase (tty, 1);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
 2006294:	80 a0 80 18 	cmp  %g2, %i0                                  
 2006298:	02 80 00 36 	be  2006370 <iproc+0x224>                      <== NEVER TAKEN
 200629c:	80 a6 20 0a 	cmp  %i0, 0xa                                  
      return 1;                                                       
    } else if (c == '\n') {                                           
 20062a0:	32 80 00 0d 	bne,a   20062d4 <iproc+0x188>                  
 20062a4:	c4 0e 60 4c 	ldub  [ %i1 + 0x4c ], %g2                      
      if (tty->termios.c_lflag & (ECHO | ECHONL))                     
 20062a8:	80 88 60 48 	btst  0x48, %g1                                
 20062ac:	22 80 00 06 	be,a   20062c4 <iproc+0x178>                   <== NEVER TAKEN
 20062b0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
        echo (c, tty);                                                
 20062b4:	90 10 20 0a 	mov  0xa, %o0                                  
 20062b8:	7f ff ff 16 	call  2005f10 <echo>                           
 20062bc:	92 10 00 19 	mov  %i1, %o1                                  
      tty->cbuf[tty->ccount++] = c;                                   
 20062c0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 20062c4:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
 20062c8:	86 10 20 0a 	mov  0xa, %g3                                  
 20062cc:	10 80 00 12 	b  2006314 <iproc+0x1c8>                       
 20062d0:	c6 28 80 01 	stb  %g3, [ %g2 + %g1 ]                        
      return 1;                                                       
    } else if ((c == tty->termios.c_cc[VEOL]) ||                      
 20062d4:	80 a0 80 18 	cmp  %g2, %i0                                  
 20062d8:	02 80 00 07 	be  20062f4 <iproc+0x1a8>                      <== NEVER TAKEN
 20062dc:	80 88 60 08 	btst  8, %g1                                   
 20062e0:	c4 0e 60 51 	ldub  [ %i1 + 0x51 ], %g2                      
 20062e4:	80 a0 80 18 	cmp  %g2, %i0                                  
 20062e8:	32 80 00 0e 	bne,a   2006320 <iproc+0x1d4>                  <== ALWAYS TAKEN
 20062ec:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
 20062f0:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
 20062f4:	22 80 00 06 	be,a   200630c <iproc+0x1c0>                   <== NOT EXECUTED
 20062f8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
        echo (c, tty);                                                
 20062fc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2006300:	7f ff ff 04 	call  2005f10 <echo>                           <== NOT EXECUTED
 2006304:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
      tty->cbuf[tty->ccount++] = c;                                   
 2006308:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
 200630c:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        <== NOT EXECUTED
 2006310:	f0 28 80 01 	stb  %i0, [ %g2 + %g1 ]                        <== NOT EXECUTED
 2006314:	82 00 60 01 	inc  %g1                                       
 2006318:	10 80 00 16 	b  2006370 <iproc+0x224>                       
 200631c:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        
  }                                                                   
                                                                      
  /*                                                                  
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
 2006320:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
 2006324:	c2 00 62 e0 	ld  [ %g1 + 0x2e0 ], %g1                       
 2006328:	82 00 7f ff 	add  %g1, -1, %g1                              
 200632c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2006330:	3a 80 00 11 	bcc,a   2006374 <iproc+0x228>                  <== NEVER TAKEN
 2006334:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    if (tty->termios.c_lflag & ECHO)                                  
 2006338:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
 200633c:	80 88 60 08 	btst  8, %g1                                   
 2006340:	22 80 00 06 	be,a   2006358 <iproc+0x20c>                   <== NEVER TAKEN
 2006344:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
      echo (c, tty);                                                  
 2006348:	90 10 00 18 	mov  %i0, %o0                                  
 200634c:	7f ff fe f1 	call  2005f10 <echo>                           
 2006350:	92 10 00 19 	mov  %i1, %o1                                  
    tty->cbuf[tty->ccount++] = c;                                     
 2006354:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 2006358:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
 200635c:	f0 28 80 01 	stb  %i0, [ %g2 + %g1 ]                        
 2006360:	82 00 60 01 	inc  %g1                                       
 2006364:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        
  }                                                                   
  return 0;                                                           
 2006368:	81 c7 e0 08 	ret                                            
 200636c:	91 e8 20 00 	restore  %g0, 0, %o0                           
    else if (c == tty->termios.c_cc[VKILL]) {                         
      erase (tty, 1);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
      return 1;                                                       
 2006370:	b0 10 20 01 	mov  1, %i0                                    
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
  }                                                                   
  return 0;                                                           
}                                                                     
 2006374:	81 c7 e0 08 	ret                                            
 2006378:	81 e8 00 00 	restore                                        
                                                                      

02019f90 <killinfo>: int killinfo( pid_t pid, int sig, const union sigval *value ) {
 2019f90:	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() )                                              
 2019f94:	7f ff ff 68 	call  2019d34 <getpid>                         
 2019f98:	01 00 00 00 	nop                                            
 2019f9c:	80 a6 00 08 	cmp  %i0, %o0                                  
 2019fa0:	02 80 00 06 	be  2019fb8 <killinfo+0x28>                    
 2019fa4:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
 2019fa8:	7f ff d5 b1 	call  200f66c <__errno>                        
 2019fac:	01 00 00 00 	nop                                            
 2019fb0:	10 80 00 a6 	b  201a248 <killinfo+0x2b8>                    
 2019fb4:	82 10 20 03 	mov  3, %g1	! 3 <PROM_START+0x3>               
                                                                      
  /*                                                                  
   *  Validate the signal passed.                                     
   */                                                                 
  if ( !sig )                                                         
 2019fb8:	32 80 00 03 	bne,a   2019fc4 <killinfo+0x34>                
 2019fbc:	ba 06 7f ff 	add  %i1, -1, %i5                              
 2019fc0:	30 80 00 04 	b,a   2019fd0 <killinfo+0x40>                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
 2019fc4:	80 a7 60 1f 	cmp  %i5, 0x1f                                 
 2019fc8:	28 80 00 06 	bleu,a   2019fe0 <killinfo+0x50>               
 2019fcc:	83 2e 60 02 	sll  %i1, 2, %g1                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
 2019fd0:	7f ff d5 a7 	call  200f66c <__errno>                        
 2019fd4:	01 00 00 00 	nop                                            
 2019fd8:	10 80 00 9c 	b  201a248 <killinfo+0x2b8>                    
 2019fdc:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
                                                                      
  /*                                                                  
   *  If the signal is being ignored, then we are out of here.        
   */                                                                 
  if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )          
 2019fe0:	85 2e 60 04 	sll  %i1, 4, %g2                               
 2019fe4:	84 20 80 01 	sub  %g2, %g1, %g2                             
 2019fe8:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 2019fec:	82 10 63 50 	or  %g1, 0x350, %g1	! 201db50 <_POSIX_signals_Vectors>
 2019ff0:	82 00 40 02 	add  %g1, %g2, %g1                             
 2019ff4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 2019ff8:	80 a0 60 01 	cmp  %g1, 1                                    
 2019ffc:	02 80 00 9f 	be  201a278 <killinfo+0x2e8>                   
 201a000:	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 ) )      
 201a004:	02 80 00 06 	be  201a01c <killinfo+0x8c>                    
 201a008:	80 a6 60 08 	cmp  %i1, 8                                    
 201a00c:	02 80 00 04 	be  201a01c <killinfo+0x8c>                    
 201a010:	80 a6 60 0b 	cmp  %i1, 0xb                                  
 201a014:	12 80 00 08 	bne  201a034 <killinfo+0xa4>                   
 201a018:	82 10 20 01 	mov  1, %g1                                    
      return pthread_kill( pthread_self(), sig );                     
 201a01c:	40 00 01 33 	call  201a4e8 <pthread_self>                   
 201a020:	01 00 00 00 	nop                                            
 201a024:	40 00 00 f4 	call  201a3f4 <pthread_kill>                   
 201a028:	92 10 00 19 	mov  %i1, %o1                                  
 201a02c:	81 c7 e0 08 	ret                                            
 201a030:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      
  /*                                                                  
   *  Build up a siginfo structure                                    
   */                                                                 
  siginfo = &siginfo_struct;                                          
  siginfo->si_signo = sig;                                            
 201a034:	f2 27 bf f4 	st  %i1, [ %fp + -12 ]                         
  siginfo->si_code = SI_USER;                                         
 201a038:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  if ( !value ) {                                                     
 201a03c:	80 a6 a0 00 	cmp  %i2, 0                                    
 201a040:	12 80 00 04 	bne  201a050 <killinfo+0xc0>                   
 201a044:	bb 28 40 1d 	sll  %g1, %i5, %i5                             
    siginfo->si_value.sival_int = 0;                                  
 201a048:	10 80 00 04 	b  201a058 <killinfo+0xc8>                     
 201a04c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  } else {                                                            
    siginfo->si_value = *value;                                       
 201a050:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 201a054:	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;                  
 201a058:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 201a05c:	c4 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g2	! 201d5d0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 201a060:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 201a064:	c4 20 61 d0 	st  %g2, [ %g1 + 0x1d0 ]                       
 */                                                                   
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 );     
 201a068:	11 00 80 72 	sethi  %hi(0x201c800), %o0                     
 201a06c:	7f ff b7 f9 	call  2008050 <_API_extensions_Add_post_switch>
 201a070:	90 12 23 a4 	or  %o0, 0x3a4, %o0	! 201cba4 <_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;                                     
 201a074:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 201a078:	d0 00 63 00 	ld  [ %g1 + 0x300 ], %o0	! 201db00 <_Per_CPU_Information+0x10>
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  if ( _POSIX_signals_Is_interested( api, mask ) ) {                  
 201a07c:	c4 02 21 5c 	ld  [ %o0 + 0x15c ], %g2                       
 201a080:	c4 00 a0 d0 	ld  [ %g2 + 0xd0 ], %g2                        
 201a084:	80 af 40 02 	andncc  %i5, %g2, %g0                          
 201a088:	12 80 00 52 	bne  201a1d0 <killinfo+0x240>                  
 201a08c:	03 00 80 77 	sethi  %hi(0x201dc00), %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 );                         
 201a090:	05 00 80 77 	sethi  %hi(0x201dc00), %g2                     
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 201a094:	c2 00 60 dc 	ld  [ %g1 + 0xdc ], %g1                        
 201a098:	10 80 00 0a 	b  201a0c0 <killinfo+0x130>                    
 201a09c:	84 10 a0 e0 	or  %g2, 0xe0, %g2                             
    #endif                                                            
                                                                      
    /*                                                                
     * Is this thread is actually blocked waiting for the signal?     
     */                                                               
    if (the_thread->Wait.option & mask)                               
 201a0a0:	80 8f 40 04 	btst  %i5, %g4                                 
 201a0a4:	12 80 00 4a 	bne  201a1cc <killinfo+0x23c>                  
 201a0a8:	c6 00 61 5c 	ld  [ %g1 + 0x15c ], %g3                       
                                                                      
    /*                                                                
     * Is this thread is blocked waiting for another signal but has   
     * not blocked this one?                                          
     */                                                               
    if (~api->signals_blocked & mask)                                 
 201a0ac:	c6 00 e0 d0 	ld  [ %g3 + 0xd0 ], %g3                        
 201a0b0:	80 af 40 03 	andncc  %i5, %g3, %g0                          
 201a0b4:	12 80 00 47 	bne  201a1d0 <killinfo+0x240>                  
 201a0b8:	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 ) {                                 
 201a0bc:	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 );                         
 201a0c0:	80 a0 40 02 	cmp  %g1, %g2                                  
 201a0c4:	32 bf ff f7 	bne,a   201a0a0 <killinfo+0x110>               
 201a0c8:	c8 00 60 30 	ld  [ %g1 + 0x30 ], %g4                        
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
 201a0cc:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 201a0d0:	c6 08 61 2c 	ldub  [ %g1 + 0x12c ], %g3	! 201c92c <rtems_maximum_priority>
                                                                      
  for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
 201a0d4:	b8 10 20 02 	mov  2, %i4                                    
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
 201a0d8:	86 00 e0 01 	inc  %g3                                       
   *                                                                  
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
 201a0dc:	82 10 20 00 	clr  %g1                                       
  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 ] )                     
 201a0e0:	1b 00 80 75 	sethi  %hi(0x201d400), %o5                     
 */                                                                   
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (        
  States_Control the_states                                           
)                                                                     
{                                                                     
   return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);              
 201a0e4:	35 04 00 00 	sethi  %hi(0x10000000), %i2                    
 */                                                                   
                                                                      
#define _POSIX_signals_Is_interested( _api, _mask ) \                 
  ( ~(_api)->signals_blocked & (_mask) )                              
                                                                      
int killinfo(                                                         
 201a0e8:	85 2f 20 02 	sll  %i4, 2, %g2                               
  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 ] )                     
 201a0ec:	88 13 61 34 	or  %o5, 0x134, %g4                            
 201a0f0:	c4 01 00 02 	ld  [ %g4 + %g2 ], %g2                         
 201a0f4:	80 a0 a0 00 	cmp  %g2, 0                                    
 201a0f8:	22 80 00 2f 	be,a   201a1b4 <killinfo+0x224>                <== NEVER TAKEN
 201a0fc:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
      continue;                                                       
                                                                      
    the_info = _Objects_Information_table[ the_api ][ 1 ];            
 201a100:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
 201a104:	b6 10 20 01 	mov  1, %i3                                    
       */                                                             
      if ( !the_info )                                                
        continue;                                                     
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
 201a108:	d8 10 a0 10 	lduh  [ %g2 + 0x10 ], %o4                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
 201a10c:	10 80 00 26 	b  201a1a4 <killinfo+0x214>                    
 201a110:	d6 00 a0 1c 	ld  [ %g2 + 0x1c ], %o3                        
      the_thread = (Thread_Control *) object_table[ index ];          
 201a114:	c4 02 c0 02 	ld  [ %o3 + %g2 ], %g2                         
                                                                      
      if ( !the_thread )                                              
 201a118:	80 a0 a0 00 	cmp  %g2, 0                                    
 201a11c:	22 80 00 22 	be,a   201a1a4 <killinfo+0x214>                
 201a120:	b6 06 e0 01 	inc  %i3                                       
                                                                      
      /*                                                              
       *  If this thread is of lower priority than the interested thread,
       *  go on to the next thread.                                   
       */                                                             
      if ( the_thread->current_priority > interested_priority )       
 201a124:	c8 00 a0 14 	ld  [ %g2 + 0x14 ], %g4                        
 201a128:	80 a1 00 03 	cmp  %g4, %g3                                  
 201a12c:	38 80 00 1e 	bgu,a   201a1a4 <killinfo+0x214>               
 201a130:	b6 06 e0 01 	inc  %i3                                       
      #if defined(RTEMS_DEBUG)                                        
        if ( !api )                                                   
          continue;                                                   
      #endif                                                          
                                                                      
      if ( !_POSIX_signals_Is_interested( api, mask ) )               
 201a134:	f0 00 a1 5c 	ld  [ %g2 + 0x15c ], %i0                       
 201a138:	f0 06 20 d0 	ld  [ %i0 + 0xd0 ], %i0                        
 201a13c:	80 af 40 18 	andncc  %i5, %i0, %g0                          
 201a140:	22 80 00 19 	be,a   201a1a4 <killinfo+0x214>                
 201a144:	b6 06 e0 01 	inc  %i3                                       
       *                                                              
       *  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 ) {     
 201a148:	80 a1 00 03 	cmp  %g4, %g3                                  
 201a14c:	2a 80 00 14 	bcs,a   201a19c <killinfo+0x20c>               
 201a150:	86 10 00 04 	mov  %g4, %g3                                  
       *  and blocking interruptibutable by signal.                   
       *                                                              
       *  If the interested thread is ready, don't think about changing.
       */                                                             
                                                                      
      if ( interested && !_States_Is_ready( interested->current_state ) ) {
 201a154:	80 a0 60 00 	cmp  %g1, 0                                    
 201a158:	22 80 00 13 	be,a   201a1a4 <killinfo+0x214>                <== NEVER TAKEN
 201a15c:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
 201a160:	de 00 60 10 	ld  [ %g1 + 0x10 ], %o7                        
 201a164:	80 a3 e0 00 	cmp  %o7, 0                                    
 201a168:	22 80 00 0f 	be,a   201a1a4 <killinfo+0x214>                <== NEVER TAKEN
 201a16c:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
        /* preferred ready over blocked */                            
        DEBUG_STEP("5");                                              
        if ( _States_Is_ready( the_thread->current_state ) ) {        
 201a170:	f0 00 a0 10 	ld  [ %g2 + 0x10 ], %i0                        
 201a174:	80 a6 20 00 	cmp  %i0, 0                                    
 201a178:	22 80 00 09 	be,a   201a19c <killinfo+0x20c>                
 201a17c:	86 10 00 04 	mov  %g4, %g3                                  
          continue;                                                   
        }                                                             
                                                                      
        DEBUG_STEP("6");                                              
        /* prefer blocked/interruptible over blocked/not interruptible */
        if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
 201a180:	80 8b c0 1a 	btst  %o7, %i2                                 
 201a184:	32 80 00 08 	bne,a   201a1a4 <killinfo+0x214>               
 201a188:	b6 06 e0 01 	inc  %i3                                       
          DEBUG_STEP("7");                                            
          if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
 201a18c:	80 8e 00 1a 	btst  %i0, %i2                                 
 201a190:	22 80 00 05 	be,a   201a1a4 <killinfo+0x214>                
 201a194:	b6 06 e0 01 	inc  %i3                                       
       */                                                             
                                                                      
      if ( interested && !_States_Is_ready( interested->current_state ) ) {
        /* preferred ready over blocked */                            
        DEBUG_STEP("5");                                              
        if ( _States_Is_ready( the_thread->current_state ) ) {        
 201a198:	86 10 00 04 	mov  %g4, %g3                                  
 201a19c:	82 10 00 02 	mov  %g2, %g1                                  
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
 201a1a0:	b6 06 e0 01 	inc  %i3                                       
 201a1a4:	80 a6 c0 0c 	cmp  %i3, %o4                                  
 201a1a8:	08 bf ff db 	bleu  201a114 <killinfo+0x184>                 
 201a1ac:	85 2e e0 02 	sll  %i3, 2, %g2                               
   *    + 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++) {
 201a1b0:	b8 07 20 01 	inc  %i4                                       
 201a1b4:	80 a7 20 04 	cmp  %i4, 4                                    
 201a1b8:	12 bf ff cd 	bne  201a0ec <killinfo+0x15c>                  
 201a1bc:	85 2f 20 02 	sll  %i4, 2, %g2                               
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( interested ) {                                                 
 201a1c0:	80 a0 60 00 	cmp  %g1, 0                                    
 201a1c4:	02 80 00 0c 	be  201a1f4 <killinfo+0x264>                   
 201a1c8:	01 00 00 00 	nop                                            
                                                                      
    /*                                                                
     * Is this thread is blocked waiting for another signal but has   
     * not blocked this one?                                          
     */                                                               
    if (~api->signals_blocked & mask)                                 
 201a1cc:	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 ) ) {  
 201a1d0:	92 10 00 19 	mov  %i1, %o1                                  
 201a1d4:	40 00 00 36 	call  201a2ac <_POSIX_signals_Unblock_thread>  
 201a1d8:	94 07 bf f4 	add  %fp, -12, %o2                             
 201a1dc:	80 8a 20 ff 	btst  0xff, %o0                                
 201a1e0:	02 80 00 05 	be  201a1f4 <killinfo+0x264>                   
 201a1e4:	01 00 00 00 	nop                                            
    _Thread_Enable_dispatch();                                        
 201a1e8:	7f ff bf 9a 	call  200a050 <_Thread_Enable_dispatch>        
 201a1ec:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
 201a1f0:	30 80 00 23 	b,a   201a27c <killinfo+0x2ec>                 
                                                                      
  /*                                                                  
   *  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 );                         
 201a1f4:	40 00 00 24 	call  201a284 <_POSIX_signals_Set_process_signals>
 201a1f8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
 201a1fc:	83 2e 60 02 	sll  %i1, 2, %g1                               
 201a200:	b3 2e 60 04 	sll  %i1, 4, %i1                               
 201a204:	b2 26 40 01 	sub  %i1, %g1, %i1                             
 201a208:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 201a20c:	82 10 63 50 	or  %g1, 0x350, %g1	! 201db50 <_POSIX_signals_Vectors>
 201a210:	c2 00 40 19 	ld  [ %g1 + %i1 ], %g1                         
 201a214:	80 a0 60 02 	cmp  %g1, 2                                    
 201a218:	12 bf ff f4 	bne  201a1e8 <killinfo+0x258>                  
 201a21c:	11 00 80 77 	sethi  %hi(0x201dc00), %o0                     
                                                                      
    psiginfo = (POSIX_signals_Siginfo_node *)                         
 201a220:	7f ff b7 f1 	call  20081e4 <_Chain_Get>                     
 201a224:	90 12 20 d0 	or  %o0, 0xd0, %o0	! 201dcd0 <_POSIX_signals_Inactive_siginfo>
               _Chain_Get( &_POSIX_signals_Inactive_siginfo );        
    if ( !psiginfo ) {                                                
 201a228:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201a22c:	12 80 00 0a 	bne  201a254 <killinfo+0x2c4>                  
 201a230:	92 07 bf f4 	add  %fp, -12, %o1                             
      _Thread_Enable_dispatch();                                      
 201a234:	7f ff bf 87 	call  200a050 <_Thread_Enable_dispatch>        
 201a238:	01 00 00 00 	nop                                            
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
 201a23c:	7f ff d5 0c 	call  200f66c <__errno>                        
 201a240:	01 00 00 00 	nop                                            
 201a244:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
 201a248:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 201a24c:	81 c7 e0 08 	ret                                            
 201a250:	91 e8 3f ff 	restore  %g0, -1, %o0                          
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
 201a254:	90 07 60 08 	add  %i5, 8, %o0                               
 201a258:	7f ff d7 56 	call  200ffb0 <memcpy>                         
 201a25c:	94 10 20 0c 	mov  0xc, %o2                                  
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
 201a260:	11 00 80 77 	sethi  %hi(0x201dc00), %o0                     
 201a264:	92 10 00 1d 	mov  %i5, %o1                                  
 201a268:	90 12 21 48 	or  %o0, 0x148, %o0                            
 201a26c:	7f ff b7 d2 	call  20081b4 <_Chain_Append>                  
 201a270:	90 02 00 19 	add  %o0, %i1, %o0                             
 201a274:	30 bf ff dd 	b,a   201a1e8 <killinfo+0x258>                 
                                                                      
  /*                                                                  
   *  If the signal is being ignored, then we are out of here.        
   */                                                                 
  if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )          
    return 0;                                                         
 201a278:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  DEBUG_STEP("\n");                                                   
  _Thread_Enable_dispatch();                                          
  return 0;                                                           
}                                                                     
 201a27c:	81 c7 e0 08 	ret                                            
 201a280:	81 e8 00 00 	restore                                        
                                                                      

02003e30 <libc_wrapup>: extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) {
 2003e30:	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()))                      
 2003e34:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 2003e38:	c2 00 62 e8 	ld  [ %g1 + 0x2e8 ], %g1	! 201dae8 <_System_state_Current>
 2003e3c:	80 a0 60 03 	cmp  %g1, 3                                    
 2003e40:	12 80 00 16 	bne  2003e98 <libc_wrapup+0x68>                <== NEVER TAKEN
 2003e44:	03 00 80 6f 	sethi  %hi(0x201bc00), %g1                     
  /*                                                                  
   *  This was already done if the user called exit() directly .      
  _wrapup_reent(0);                                                   
   */                                                                 
                                                                      
  if (_REENT != _global_impure_ptr) {                                 
 2003e48:	39 00 80 73 	sethi  %hi(0x201cc00), %i4                     
 2003e4c:	fa 00 62 a0 	ld  [ %g1 + 0x2a0 ], %i5                       
 2003e50:	c2 07 20 60 	ld  [ %i4 + 0x60 ], %g1                        
 2003e54:	80 a0 40 1d 	cmp  %g1, %i5                                  
 2003e58:	22 80 00 06 	be,a   2003e70 <libc_wrapup+0x40>              
 2003e5c:	3b 00 80 73 	sethi  %hi(0x201cc00), %i5                     
      _wrapup_reent(_global_impure_ptr);                              
 2003e60:	40 00 31 32 	call  2010328 <_wrapup_reent>                  
 2003e64:	90 10 00 1d 	mov  %i5, %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;                                    
 2003e68:	fa 27 20 60 	st  %i5, [ %i4 + 0x60 ]                        
   *                                                                  
   * Should this be changed to do *all* file streams?                 
   *    _fwalk (_REENT, fclose);                                      
   */                                                                 
                                                                      
  fclose (stdin);                                                     
 2003e6c:	3b 00 80 73 	sethi  %hi(0x201cc00), %i5                     
 2003e70:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1	! 201cc60 <_impure_ptr>
 2003e74:	40 00 2e 50 	call  200f7b4 <fclose>                         
 2003e78:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
  fclose (stdout);                                                    
 2003e7c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 2003e80:	40 00 2e 4d 	call  200f7b4 <fclose>                         
 2003e84:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
  fclose (stderr);                                                    
 2003e88:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 2003e8c:	f0 00 60 0c 	ld  [ %g1 + 0xc ], %i0                         
 2003e90:	40 00 2e 49 	call  200f7b4 <fclose>                         
 2003e94:	81 e8 00 00 	restore                                        
 2003e98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003e9c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003900 <malloc>: #include "malloc_p.h" void *malloc( size_t size ) {
 2003900:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void        *return_this;                                           
                                                                      
  MSBUMP(malloc_calls, 1);                                            
 2003904:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2003908:	82 10 60 50 	or  %g1, 0x50, %g1	! 201d450 <rtems_malloc_statistics>
 200390c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
 2003910:	84 00 a0 01 	inc  %g2                                       
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
 2003914:	7f ff ff b9 	call  20037f8 <malloc_deferred_frees_process>  
 2003918:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
 200391c:	80 a6 20 00 	cmp  %i0, 0                                    
 2003920:	12 80 00 04 	bne  2003930 <malloc+0x30>                     
 2003924:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
    return (void *) 0;                                                
 2003928:	10 80 00 32 	b  20039f0 <malloc+0xf0>                       
 200392c:	ba 10 20 00 	clr  %i5                                       
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
 2003930:	c2 00 62 e8 	ld  [ %g1 + 0x2e8 ], %g1                       
 2003934:	80 a0 60 03 	cmp  %g1, 3                                    
 2003938:	02 80 00 0c 	be  2003968 <malloc+0x68>                      
 200393c:	39 00 80 72 	sethi  %hi(0x201c800), %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 );
 2003940:	d0 07 21 b0 	ld  [ %i4 + 0x1b0 ], %o0	! 201c9b0 <RTEMS_Malloc_Heap>
 2003944:	92 10 00 18 	mov  %i0, %o1                                  
 2003948:	94 10 20 00 	clr  %o2                                       
 200394c:	40 00 16 9b 	call  20093b8 <_Protected_heap_Allocate_aligned_with_boundary>
 2003950:	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 ) {                                               
 2003954:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2003958:	12 80 00 18 	bne  20039b8 <malloc+0xb8>                     
 200395c:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
 2003960:	10 80 00 09 	b  2003984 <malloc+0x84>                       
 2003964:	d0 07 21 b0 	ld  [ %i4 + 0x1b0 ], %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() )                                 
 2003968:	7f ff ff 98 	call  20037c8 <malloc_is_system_state_OK>      
 200396c:	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()) &&                    
 2003970:	80 8a 20 ff 	btst  0xff, %o0                                
 2003974:	12 bf ff f3 	bne  2003940 <malloc+0x40>                     <== ALWAYS TAKEN
 2003978:	01 00 00 00 	nop                                            
 200397c:	10 80 00 1d 	b  20039f0 <malloc+0xf0>                       <== NOT EXECUTED
 2003980:	ba 10 20 00 	clr  %i5	! 0 <PROM_START>                      <== NOT EXECUTED
   */                                                                 
                                                                      
  return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );  
                                                                      
  if ( !return_this ) {                                               
    return_this = (*rtems_malloc_extend_handler)( RTEMS_Malloc_Heap, size );
 2003984:	03 00 80 69 	sethi  %hi(0x201a400), %g1                     
 2003988:	c2 00 63 c0 	ld  [ %g1 + 0x3c0 ], %g1	! 201a7c0 <rtems_malloc_extend_handler>
 200398c:	9f c0 40 00 	call  %g1                                      
 2003990:	92 10 00 18 	mov  %i0, %o1                                  
    if ( !return_this ) {                                             
 2003994:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2003998:	12 80 00 08 	bne  20039b8 <malloc+0xb8>                     <== NEVER TAKEN
 200399c:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
      errno = ENOMEM;                                                 
 20039a0:	40 00 2f 33 	call  200f66c <__errno>                        
 20039a4:	b0 10 00 1d 	mov  %i5, %i0                                  
 20039a8:	82 10 20 0c 	mov  0xc, %g1                                  
 20039ac:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 20039b0:	81 c7 e0 08 	ret                                            
 20039b4:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  /*                                                                  
   *  If the user wants us to dirty the allocated memory, then do it. 
   */                                                                 
  if ( rtems_malloc_dirty_helper )                                    
 20039b8:	c2 00 61 8c 	ld  [ %g1 + 0x18c ], %g1                       
 20039bc:	80 a0 60 00 	cmp  %g1, 0                                    
 20039c0:	02 80 00 04 	be  20039d0 <malloc+0xd0>                      
 20039c4:	90 10 00 1d 	mov  %i5, %o0                                  
    (*rtems_malloc_dirty_helper)( return_this, size );                
 20039c8:	9f c0 40 00 	call  %g1                                      
 20039cc:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
 20039d0:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 20039d4:	c2 00 61 90 	ld  [ %g1 + 0x190 ], %g1	! 201d190 <rtems_malloc_statistics_helpers>
 20039d8:	80 a0 60 00 	cmp  %g1, 0                                    
 20039dc:	22 80 00 06 	be,a   20039f4 <malloc+0xf4>                   
 20039e0:	b0 10 00 1d 	mov  %i5, %i0                                  
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
 20039e4:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 20039e8:	9f c0 40 00 	call  %g1                                      
 20039ec:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return return_this;                                                 
}                                                                     
 20039f0:	b0 10 00 1d 	mov  %i5, %i0                                  
 20039f4:	81 c7 e0 08 	ret                                            
 20039f8:	81 e8 00 00 	restore                                        
                                                                      

0200dcc8 <memfile_alloc_block>: * Allocate a block for an in-memory file. */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) {
 200dcc8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *memory;                                                       
                                                                      
  memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);           
 200dccc:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200dcd0:	d2 00 61 b8 	ld  [ %g1 + 0x1b8 ], %o1	! 201d1b8 <imfs_memfile_bytes_per_block>
 200dcd4:	7f ff d5 84 	call  20032e4 <calloc>                         
 200dcd8:	90 10 20 01 	mov  1, %o0                                    
  if ( memory )                                                       
 200dcdc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200dce0:	02 80 00 05 	be  200dcf4 <memfile_alloc_block+0x2c>         <== NEVER TAKEN
 200dce4:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    memfile_blocks_allocated++;                                       
 200dce8:	c4 00 62 cc 	ld  [ %g1 + 0x2cc ], %g2	! 201d2cc <memfile_blocks_allocated>
 200dcec:	84 00 a0 01 	inc  %g2                                       
 200dcf0:	c4 20 62 cc 	st  %g2, [ %g1 + 0x2cc ]                       
                                                                      
  return memory;                                                      
}                                                                     
 200dcf4:	81 c7 e0 08 	ret                                            
 200dcf8:	81 e8 00 00 	restore                                        
                                                                      

0200e7f0 <memfile_ftruncate>: int memfile_ftruncate( rtems_libio_t *iop, off_t length ) {
 200e7f0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
 200e7f4:	fa 06 20 1c 	ld  [ %i0 + 0x1c ], %i5                        
   *  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 )                           
 200e7f8:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
 200e7fc:	80 a0 40 19 	cmp  %g1, %i1                                  
 200e800:	06 80 00 09 	bl  200e824 <memfile_ftruncate+0x34>           <== NEVER TAKEN
 200e804:	90 10 00 1d 	mov  %i5, %o0                                  
 200e808:	32 80 00 0d 	bne,a   200e83c <memfile_ftruncate+0x4c>       <== NEVER TAKEN
 200e80c:	f2 27 60 50 	st  %i1, [ %i5 + 0x50 ]                        <== NOT EXECUTED
 200e810:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
 200e814:	80 a0 40 1a 	cmp  %g1, %i2                                  
 200e818:	3a 80 00 09 	bcc,a   200e83c <memfile_ftruncate+0x4c>       
 200e81c:	f2 27 60 50 	st  %i1, [ %i5 + 0x50 ]                        
    return IMFS_memfile_extend( the_jnode, true, length );            
 200e820:	90 10 00 1d 	mov  %i5, %o0                                  
 200e824:	92 10 20 01 	mov  1, %o1                                    
 200e828:	94 10 00 19 	mov  %i1, %o2                                  
 200e82c:	7f ff fe df 	call  200e3a8 <IMFS_memfile_extend>            
 200e830:	96 10 00 1a 	mov  %i2, %o3                                  
 200e834:	81 c7 e0 08 	ret                                            
 200e838:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  /*                                                                  
   *  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;                                 
 200e83c:	f4 27 60 54 	st  %i2, [ %i5 + 0x54 ]                        
                                                                      
  IMFS_update_atime( the_jnode );                                     
 200e840:	90 07 bf f8 	add  %fp, -8, %o0                              
 200e844:	7f ff d3 85 	call  2003658 <gettimeofday>                   
 200e848:	92 10 20 00 	clr  %o1                                       
 200e84c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200e850:	c2 27 60 40 	st  %g1, [ %i5 + 0x40 ]                        
                                                                      
  return 0;                                                           
}                                                                     
 200e854:	81 c7 e0 08 	ret                                            
 200e858:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

0200e774 <memfile_open>: rtems_libio_t *iop, const char *pathname, int oflag, mode_t mode ) {
 200e774:	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)                                
 200e778:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
 200e77c:	80 88 60 04 	btst  4, %g1                                   
 200e780:	12 80 00 04 	bne  200e790 <memfile_open+0x1c>               
 200e784:	d0 06 20 1c 	ld  [ %i0 + 0x1c ], %o0                        
    if ((count != 0)                                                  
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
        return -1;                                                    
  }                                                                   
                                                                      
  return 0;                                                           
 200e788:	81 c7 e0 08 	ret                                            
 200e78c:	91 e8 20 00 	restore  %g0, 0, %o0                           
 200e790:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
                                                                      
  /*                                                                  
   * Perform 'copy on write' for linear files                         
   */                                                                 
  if ((iop->flags & LIBIO_FLAGS_WRITE)                                
   && (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {                 
 200e794:	c2 00 40 00 	ld  [ %g1 ], %g1                               
 200e798:	80 a0 60 05 	cmp  %g1, 5                                    
 200e79c:	12 bf ff fb 	bne  200e788 <memfile_open+0x14>               <== ALWAYS TAKEN
 200e7a0:	03 00 80 6d 	sethi  %hi(0x201b400), %g1                     
    uint32_t   count = the_jnode->info.linearfile.size;               
 200e7a4:	d8 02 20 54 	ld  [ %o0 + 0x54 ], %o4                        <== NOT EXECUTED
    const unsigned char *buffer = the_jnode->info.linearfile.direct;  
 200e7a8:	d6 02 20 58 	ld  [ %o0 + 0x58 ], %o3                        <== NOT EXECUTED
                                                                      
    the_jnode->control = &IMFS_node_control_memfile;                  
    the_jnode->info.file.size            = 0;                         
 200e7ac:	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;                  
 200e7b0:	82 10 63 34 	or  %g1, 0x334, %g1                            <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
 200e7b4:	c0 22 20 54 	clr  [ %o0 + 0x54 ]                            <== 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;                  
 200e7b8:	c2 22 20 4c 	st  %g1, [ %o0 + 0x4c ]                        <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
    the_jnode->info.file.indirect        = 0;                         
 200e7bc:	c0 22 20 58 	clr  [ %o0 + 0x58 ]                            <== NOT EXECUTED
    the_jnode->info.file.doubly_indirect = 0;                         
 200e7c0:	c0 22 20 5c 	clr  [ %o0 + 0x5c ]                            <== NOT EXECUTED
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
 200e7c4:	80 a3 20 00 	cmp  %o4, 0                                    <== NOT EXECUTED
 200e7c8:	02 bf ff f0 	be  200e788 <memfile_open+0x14>                <== NOT EXECUTED
 200e7cc:	c0 22 20 60 	clr  [ %o0 + 0x60 ]                            <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
 200e7d0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 200e7d4:	7f ff ff 5d 	call  200e548 <IMFS_memfile_write>             <== NOT EXECUTED
 200e7d8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
        return -1;                                                    
 200e7dc:	90 38 00 08 	xnor  %g0, %o0, %o0                            <== NOT EXECUTED
 200e7e0:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
 200e7e4:	b0 40 3f ff 	addx  %g0, -1, %i0                             <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 200e7e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e7ec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003b1c <mount>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
 2003b1c:	9d e3 bf 50 	save  %sp, -176, %sp                           
  int rv = 0;                                                         
                                                                      
  if (                                                                
 2003b20:	80 a6 e0 01 	cmp  %i3, 1                                    
 2003b24:	18 80 00 b4 	bgu  2003df4 <mount+0x2d8>                     
 2003b28:	01 00 00 00 	nop                                            
    options == RTEMS_FILESYSTEM_READ_ONLY                             
      || options == RTEMS_FILESYSTEM_READ_WRITE                       
  ) {                                                                 
    rtems_filesystem_fsmount_me_t fsmount_me_h =                      
 2003b2c:	40 00 21 90 	call  200c16c <rtems_filesystem_get_mount_handler>
 2003b30:	90 10 00 1a 	mov  %i2, %o0                                  
      rtems_filesystem_get_mount_handler( filesystemtype );           
                                                                      
    if ( fsmount_me_h != NULL ) {                                     
 2003b34:	a6 92 20 00 	orcc  %o0, 0, %l3                              
 2003b38:	02 80 00 af 	be  2003df4 <mount+0x2d8>                      
 2003b3c:	a2 96 60 00 	orcc  %i1, 0, %l1                              
  const char *target_or_null,                                         
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
 2003b40:	12 80 00 04 	bne  2003b50 <mount+0x34>                      
 2003b44:	01 00 00 00 	nop                                            
 2003b48:	23 00 80 6c 	sethi  %hi(0x201b000), %l1                     
 2003b4c:	a2 14 63 40 	or  %l1, 0x340, %l1	! 201b340 <rtems_status_assoc+0x1a0>
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
 2003b50:	40 00 34 4e 	call  2010c88 <strlen>                         
 2003b54:	90 10 00 1a 	mov  %i2, %o0                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
 2003b58:	80 a6 20 00 	cmp  %i0, 0                                    
  const char *filesystemtype,                                         
  size_t *target_length_ptr                                           
)                                                                     
{                                                                     
  const char *target = target_or_null != NULL ? target_or_null : "/"; 
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
 2003b5c:	ba 10 00 08 	mov  %o0, %i5                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
 2003b60:	02 80 00 06 	be  2003b78 <mount+0x5c>                       
 2003b64:	ac 02 20 01 	add  %o0, 1, %l6                               
 2003b68:	40 00 34 48 	call  2010c88 <strlen>                         
 2003b6c:	90 10 00 18 	mov  %i0, %o0                                  
 2003b70:	10 80 00 03 	b  2003b7c <mount+0x60>                        
 2003b74:	a0 02 20 01 	add  %o0, 1, %l0                               
 2003b78:	a0 10 20 00 	clr  %l0                                       
  size_t target_size = strlen( target ) + 1;                          
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
 2003b7c:	ba 07 60 65 	add  %i5, 0x65, %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;                                 
  size_t target_size = strlen( target ) + 1;                          
 2003b80:	40 00 34 42 	call  2010c88 <strlen>                         
 2003b84:	90 10 00 11 	mov  %l1, %o0                                  
  size_t size = sizeof( rtems_filesystem_mount_table_entry_t )        
    + filesystemtype_size + source_size + target_size                 
 2003b88:	92 07 40 10 	add  %i5, %l0, %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;                                 
  size_t target_size = strlen( target ) + 1;                          
 2003b8c:	aa 02 20 01 	add  %o0, 1, %l5                               
  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 ); 
 2003b90:	90 10 20 01 	mov  1, %o0                                    
 2003b94:	7f ff fd d4 	call  20032e4 <calloc>                         
 2003b98:	92 02 40 15 	add  %o1, %l5, %o1                             
                                                                      
  if ( mt_entry != NULL ) {                                           
 2003b9c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2003ba0:	02 80 00 9d 	be  2003e14 <mount+0x2f8>                      <== NEVER TAKEN
 2003ba4:	a4 07 60 64 	add  %i5, 0x64, %l2                            
    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 );               
 2003ba8:	92 10 00 1a 	mov  %i2, %o1                                  
 2003bac:	90 10 00 12 	mov  %l2, %o0                                  
 2003bb0:	40 00 31 00 	call  200ffb0 <memcpy>                         
 2003bb4:	94 10 00 16 	mov  %l6, %o2                                  
    mt_entry->type = str;                                             
 2003bb8:	e4 27 60 34 	st  %l2, [ %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 =                  
 2003bbc:	a8 07 60 40 	add  %i5, 0x40, %l4                            
                                                                      
    memcpy( str, filesystemtype, filesystemtype_size );               
    mt_entry->type = str;                                             
    str += filesystemtype_size;                                       
                                                                      
    if ( source_or_null != NULL ) {                                   
 2003bc0:	80 a6 20 00 	cmp  %i0, 0                                    
 2003bc4:	02 80 00 08 	be  2003be4 <mount+0xc8>                       
 2003bc8:	b4 04 80 16 	add  %l2, %l6, %i2                             
      memcpy( str, source_or_null, source_size );                     
 2003bcc:	90 10 00 1a 	mov  %i2, %o0                                  
 2003bd0:	92 10 00 18 	mov  %i0, %o1                                  
 2003bd4:	40 00 30 f7 	call  200ffb0 <memcpy>                         
 2003bd8:	94 10 00 10 	mov  %l0, %o2                                  
      mt_entry->dev = str;                                            
 2003bdc:	f4 27 60 38 	st  %i2, [ %i5 + 0x38 ]                        
      str += source_size;                                             
 2003be0:	b4 06 80 10 	add  %i2, %l0, %i2                             
    }                                                                 
                                                                      
    memcpy( str, target, target_size );                               
 2003be4:	92 10 00 11 	mov  %l1, %o1                                  
 2003be8:	94 10 00 15 	mov  %l5, %o2                                  
 2003bec:	40 00 30 f1 	call  200ffb0 <memcpy>                         
 2003bf0:	90 10 00 1a 	mov  %i2, %o0                                  
    mt_entry->target = str;                                           
    str += target_size;                                               
                                                                      
    mt_entry->mounted = true;                                         
 2003bf4:	82 10 20 01 	mov  1, %g1                                    
 2003bf8:	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;
 2003bfc:	03 00 80 6c 	sethi  %hi(0x201b000), %g1                     
 2003c00:	82 10 63 44 	or  %g1, 0x344, %g1	! 201b344 <rtems_filesystem_default_pathconf>
 2003c04:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
                                                                      
    mt_fs_root->location.mt_entry = mt_entry;                         
    mt_fs_root->reference_count = 1;                                  
 2003c08:	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 );
 2003c0c:	90 07 60 14 	add  %i5, 0x14, %o0                            
 2003c10:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]                        
 2003c14:	92 10 00 14 	mov  %l4, %o1                                  
 2003c18:	94 10 20 01 	mov  1, %o2                                    
 2003c1c:	96 10 20 24 	mov  0x24, %o3                                 
      mt_entry->dev = str;                                            
      str += source_size;                                             
    }                                                                 
                                                                      
    memcpy( str, target, target_size );                               
    mt_entry->target = str;                                           
 2003c20:	f4 27 60 30 	st  %i2, [ %i5 + 0x30 ]                        
    str += target_size;                                               
                                                                      
    mt_entry->mounted = true;                                         
    mt_entry->mt_fs_root = mt_fs_root;                                
 2003c24:	e8 27 60 24 	st  %l4, [ %i5 + 0x24 ]                        
 2003c28:	40 00 11 7e 	call  2008220 <_Chain_Initialize>              
 2003c2c:	fa 27 60 54 	st  %i5, [ %i5 + 0x54 ]                        
        filesystemtype,                                               
        &target_length                                                
      );                                                              
                                                                      
      if ( mt_entry != NULL ) {                                       
        mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 
 2003c30:	b6 0e e0 01 	and  %i3, 1, %i3                               
                                                                      
        rv = (*fsmount_me_h)( mt_entry, data );                       
 2003c34:	90 10 00 1d 	mov  %i5, %o0                                  
        filesystemtype,                                               
        &target_length                                                
      );                                                              
                                                                      
      if ( mt_entry != NULL ) {                                       
        mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 
 2003c38:	f6 2f 60 29 	stb  %i3, [ %i5 + 0x29 ]                       
                                                                      
        rv = (*fsmount_me_h)( mt_entry, data );                       
 2003c3c:	9f c4 c0 00 	call  %l3                                      
 2003c40:	92 10 00 1c 	mov  %i4, %o1                                  
        if ( rv == 0 ) {                                              
 2003c44:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003c48:	12 80 00 6f 	bne  2003e04 <mount+0x2e8>                     
 2003c4c:	80 a6 60 00 	cmp  %i1, 0                                    
          if ( target != NULL ) {                                     
 2003c50:	02 80 00 38 	be  2003d30 <mount+0x214>                      
 2003c54:	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 =                      
 2003c58:	94 10 20 1f 	mov  0x1f, %o2                                 
 2003c5c:	40 00 02 fd 	call  2004850 <rtems_filesystem_eval_path_start>
 2003c60:	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;
 2003c64:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
                                                                      
  return (*mt_entry->ops->are_nodes_equal_h)(                         
 2003c68:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 2003c6c:	c4 00 a0 10 	ld  [ %g2 + 0x10 ], %g2                        
 2003c70:	9f c0 80 00 	call  %g2                                      
 2003c74:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
    rtems_filesystem_eval_path_start( &ctx, target, eval_flags );     
                                                                      
  if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {  
 2003c78:	80 8a 20 ff 	btst  0xff, %o0                                
 2003c7c:	12 80 00 22 	bne  2003d04 <mount+0x1e8>                     
 2003c80:	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(                          
 2003c84:	40 00 03 ed 	call  2004c38 <rtems_filesystem_location_copy_and_detach>
 2003c88:	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 );
 2003c8c:	40 00 04 63 	call  2004e18 <rtems_filesystem_location_transform_to_global>
 2003c90:	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 );
 2003c94:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %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;                          
 2003c98:	d0 27 60 20 	st  %o0, [ %i5 + 0x20 ]                        
    rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
 2003c9c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %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 );
 2003ca0:	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 );
 2003ca4:	c2 00 60 30 	ld  [ %g1 + 0x30 ], %g1                        
 2003ca8:	9f c0 40 00 	call  %g1                                      
 2003cac:	90 10 00 1d 	mov  %i5, %o0                                  
    if ( rv == 0 ) {                                                  
 2003cb0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003cb4:	12 80 00 11 	bne  2003cf8 <mount+0x1dc>                     
 2003cb8:	92 10 20 00 	clr  %o1                                       
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
 2003cbc:	39 00 80 75 	sethi  %hi(0x201d400), %i4                     
 2003cc0:	d0 07 20 4c 	ld  [ %i4 + 0x4c ], %o0	! 201d44c <rtems_libio_semaphore>
 2003cc4:	40 00 0e 80 	call  20076c4 <rtems_semaphore_obtain>         
 2003cc8:	94 10 20 00 	clr  %o2                                       
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 2003ccc:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
 2003cd0:	d0 07 20 4c 	ld  [ %i4 + 0x4c ], %o0                        
 2003cd4:	82 10 62 c8 	or  %g1, 0x2c8, %g1                            
 2003cd8:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
 2003cdc:	86 00 60 04 	add  %g1, 4, %g3                               
 2003ce0:	c6 27 40 00 	st  %g3, [ %i5 ]                               
  tail->previous = the_node;                                          
 2003ce4:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
  old_last->next = the_node;                                          
 2003ce8:	fa 20 80 00 	st  %i5, [ %g2 ]                               
 2003cec:	40 00 0e bf 	call  20077e8 <rtems_semaphore_release>        
 2003cf0:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
 2003cf4:	30 80 00 08 	b,a   2003d14 <mount+0x1f8>                    
        &rtems_filesystem_mount_table,                                
        &mt_entry->mt_node                                            
      );                                                              
      rtems_filesystem_mt_unlock();                                   
    } else {                                                          
      rtems_filesystem_global_location_release( mt_point_node );      
 2003cf8:	40 00 03 f5 	call  2004ccc <rtems_filesystem_global_location_release>
 2003cfc:	90 10 00 1c 	mov  %i4, %o0                                  
 2003d00:	30 80 00 05 	b,a   2003d14 <mount+0x1f8>                    
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error( &ctx, EBUSY );                  
 2003d04:	90 07 bf c8 	add  %fp, -56, %o0                             
 2003d08:	92 10 20 10 	mov  0x10, %o1                                 
 2003d0c:	40 00 02 3b 	call  20045f8 <rtems_filesystem_eval_path_error>
 2003d10:	b0 10 3f ff 	mov  -1, %i0                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
 2003d14:	40 00 03 0b 	call  2004940 <rtems_filesystem_eval_path_cleanup>
 2003d18:	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 ) {                                            
 2003d1c:	80 a6 20 00 	cmp  %i0, 0                                    
 2003d20:	02 80 00 42 	be  2003e28 <mount+0x30c>                      
 2003d24:	01 00 00 00 	nop                                            
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
 2003d28:	10 80 00 2f 	b  2003de4 <mount+0x2c8>                       
 2003d2c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
 2003d30:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2003d34:	d0 00 60 4c 	ld  [ %g1 + 0x4c ], %o0	! 201d44c <rtems_libio_semaphore>
 2003d38:	92 10 20 00 	clr  %o1                                       
 2003d3c:	40 00 0e 62 	call  20076c4 <rtems_semaphore_obtain>         
 2003d40:	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;                    
 2003d44:	05 00 80 72 	sethi  %hi(0x201c800), %g2                     
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  rtems_filesystem_mt_lock();                                         
  if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {      
 2003d48:	c6 00 a2 c8 	ld  [ %g2 + 0x2c8 ], %g3	! 201cac8 <rtems_filesystem_mount_table>
 2003d4c:	82 10 a2 c8 	or  %g2, 0x2c8, %g1                            
 2003d50:	84 00 60 04 	add  %g1, 4, %g2                               
 2003d54:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2003d58:	12 80 00 08 	bne  2003d78 <mount+0x25c>                     <== NEVER TAKEN
 2003d5c:	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;                              
 2003d60:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
 2003d64:	c6 27 40 00 	st  %g3, [ %i5 ]                               
  tail->previous = the_node;                                          
 2003d68:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
  old_last->next = the_node;                                          
 2003d6c:	fa 20 80 00 	st  %i5, [ %g2 ]                               
  the_node->previous = old_last;                                      
 2003d70:	10 80 00 06 	b  2003d88 <mount+0x26c>                       
 2003d74:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
    rtems_chain_append_unprotected(                                   
      &rtems_filesystem_mount_table,                                  
      &mt_entry->mt_node                                              
    );                                                                
  } else {                                                            
    errno = EINVAL;                                                   
 2003d78:	40 00 2e 3d 	call  200f66c <__errno>                        <== NOT EXECUTED
 2003d7c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2003d80:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
 2003d84:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
 2003d88:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2003d8c:	40 00 0e 97 	call  20077e8 <rtems_semaphore_release>        
 2003d90:	d0 00 60 4c 	ld  [ %g1 + 0x4c ], %o0	! 201d44c <rtems_libio_semaphore>
    rv = -1;                                                          
  }                                                                   
  rtems_filesystem_mt_unlock();                                       
                                                                      
  if ( rv == 0 ) {                                                    
 2003d94:	80 a6 20 00 	cmp  %i0, 0                                    
 2003d98:	32 80 00 13 	bne,a   2003de4 <mount+0x2c8>                  <== NEVER TAKEN
 2003d9c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
    rtems_filesystem_global_location_t *new_fs_root =                 
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
 2003da0:	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 =                 
 2003da4:	40 00 03 eb 	call  2004d50 <rtems_filesystem_global_location_obtain>
 2003da8:	90 10 00 1d 	mov  %i5, %o0                                  
 2003dac:	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 =              
 2003db0:	40 00 03 e8 	call  2004d50 <rtems_filesystem_global_location_obtain>
 2003db4:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
                                                                      
    rtems_filesystem_global_location_assign(                          
 2003db8:	3b 00 80 72 	sethi  %hi(0x201c800), %i5                     
  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 =              
 2003dbc:	b8 10 00 08 	mov  %o0, %i4                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
                                                                      
    rtems_filesystem_global_location_assign(                          
 2003dc0:	d0 07 62 e8 	ld  [ %i5 + 0x2e8 ], %o0                       
 2003dc4:	92 10 00 1b 	mov  %i3, %o1                                  
 2003dc8:	40 00 03 d9 	call  2004d2c <rtems_filesystem_global_location_assign>
 2003dcc:	90 02 20 04 	add  %o0, 4, %o0                               
      &rtems_filesystem_root,                                         
      new_fs_root                                                     
    );                                                                
    rtems_filesystem_global_location_assign(                          
 2003dd0:	d0 07 62 e8 	ld  [ %i5 + 0x2e8 ], %o0                       
 2003dd4:	40 00 03 d6 	call  2004d2c <rtems_filesystem_global_location_assign>
 2003dd8:	92 10 00 1c 	mov  %i4, %o1                                  
 2003ddc:	81 c7 e0 08 	ret                                            
 2003de0:	81 e8 00 00 	restore                                        
          } else {                                                    
            rv = register_root_file_system( mt_entry );               
          }                                                           
                                                                      
          if ( rv != 0 ) {                                            
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
 2003de4:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        
 2003de8:	9f c0 40 00 	call  %g1                                      
 2003dec:	90 10 00 1d 	mov  %i5, %o0                                  
 2003df0:	30 80 00 05 	b,a   2003e04 <mount+0x2e8>                    
    } else {                                                          
      errno = EINVAL;                                                 
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
 2003df4:	40 00 2e 1e 	call  200f66c <__errno>                        
 2003df8:	01 00 00 00 	nop                                            
 2003dfc:	10 80 00 09 	b  2003e20 <mount+0x304>                       
 2003e00:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
          }                                                           
        }                                                             
                                                                      
        if ( rv != 0 ) {                                              
          free( mt_entry );                                           
 2003e04:	7f ff fd eb 	call  20035b0 <free>                           
 2003e08:	90 10 00 1d 	mov  %i5, %o0                                  
 2003e0c:	81 c7 e0 08 	ret                                            
 2003e10:	81 e8 00 00 	restore                                        
        }                                                             
      } else {                                                        
        errno = ENOMEM;                                               
 2003e14:	40 00 2e 16 	call  200f66c <__errno>                        <== NOT EXECUTED
 2003e18:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2003e1c:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
 2003e20:	c2 22 00 00 	st  %g1, [ %o0 ]                               
        rv = -1;                                                      
 2003e24:	b0 10 3f ff 	mov  -1, %i0                                   
    errno = EINVAL;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2003e28:	81 c7 e0 08 	ret                                            
 2003e2c:	81 e8 00 00 	restore                                        
                                                                      

02008844 <mount_and_make_target_path>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
 2008844:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
 2008848:	90 96 60 00 	orcc  %i1, 0, %o0                              
 200884c:	02 80 00 09 	be  2008870 <mount_and_make_target_path+0x2c>  
 2008850:	01 00 00 00 	nop                                            
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
 2008854:	40 00 02 f1 	call  2009418 <rtems_mkdir>                    
 2008858:	92 10 21 ff 	mov  0x1ff, %o1	! 1ff <PROM_START+0x1ff>       
    if (rv == 0) {                                                    
 200885c:	80 a2 20 00 	cmp  %o0, 0                                    
 2008860:	12 80 00 09 	bne  2008884 <mount_and_make_target_path+0x40> <== NEVER TAKEN
 2008864:	01 00 00 00 	nop                                            
      rv = mount(                                                     
 2008868:	40 00 00 09 	call  200888c <mount>                          
 200886c:	81 e8 00 00 	restore                                        
        options,                                                      
        data                                                          
      );                                                              
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
 2008870:	40 00 60 6c 	call  2020a20 <__errno>                        
 2008874:	01 00 00 00 	nop                                            
 2008878:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 200887c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  const char *filesystemtype,                                         
  rtems_filesystem_options_t options,                                 
  const void *data                                                    
)                                                                     
{                                                                     
  int rv = -1;                                                        
 2008880:	90 10 3f ff 	mov  -1, %o0                                   
  } else {                                                            
    errno = EINVAL;                                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2008884:	81 c7 e0 08 	ret                                            
 2008888:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020176f0 <msdos_creat_node>: msdos_node_type_t type, const char *name, int name_len, mode_t mode, const fat_file_fd_t *link_fd) {
 20176f0:	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;        
 20176f4:	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);         
 20176f8:	92 10 20 00 	clr  %o1                                       
                 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;        
 20176fc:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
 2017700:	82 10 3f ff 	mov  -1, %g1                                   
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
 2017704:	94 10 20 20 	mov  0x20, %o2                                 
 2017708:	c2 27 bf 78 	st  %g1, [ %fp + -136 ]                        
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
 201770c:	c2 27 bf 7c 	st  %g1, [ %fp + -132 ]                        
                 const fat_file_fd_t                     *link_fd)    
{                                                                     
    int               rc = RC_OK;                                     
    ssize_t           ret = 0;                                        
    msdos_fs_info_t  *fs_info = parent_loc->mt_entry->fs_info;        
    fat_file_fd_t    *parent_fat_fd = parent_loc->node_access;        
 2017710:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
    fat_file_fd_t    *fat_fd = NULL;                                  
 2017714:	c0 27 bf 6c 	clr  [ %fp + -148 ]                            
    time_t            time_ret = 0;                                   
    uint16_t          time_val = 0;                                   
 2017718:	c0 37 bf 68 	clrh  [ %fp + -152 ]                           
    uint16_t          date = 0;                                       
 201771c:	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;                                             
 2017720:	c0 27 bf 70 	clr  [ %fp + -144 ]                            
  dir_pos->sname.ofs = 0;                                             
 2017724:	c0 27 bf 74 	clr  [ %fp + -140 ]                            
    uint32_t          sec = 0;                                        
    uint32_t          byte = 0;                                       
                                                                      
    fat_dir_pos_init(&dir_pos);                                       
                                                                      
    memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);         
 2017728:	40 00 12 9d 	call  201c19c <memset>                         
 201772c:	90 07 bf 80 	add  %fp, -128, %o0                            
    memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);     
 2017730:	90 07 bf c0 	add  %fp, -64, %o0                             
 2017734:	92 10 20 00 	clr  %o1                                       
 2017738:	40 00 12 99 	call  201c19c <memset>                         
 201773c:	94 10 20 40 	mov  0x40, %o2                                 
                                                                      
    if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {                     
 2017740:	80 a6 e1 04 	cmp  %i3, 0x104                                
 2017744:	24 80 00 06 	ble,a   201775c <msdos_creat_node+0x6c>        <== ALWAYS TAKEN
 2017748:	90 10 00 1a 	mov  %i2, %o0                                  
        rtems_set_errno_and_return_minus_one(ENAMETOOLONG);           
 201774c:	40 00 0f 98 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2017750:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2017754:	10 80 00 0c 	b  2017784 <msdos_creat_node+0x94>             <== NOT EXECUTED
 2017758:	82 10 20 5b 	mov  0x5b, %g1	! 5b <PROM_START+0x5b>          <== NOT EXECUTED
    }                                                                 
                                                                      
    name_type = msdos_long_to_short (name, name_len,                  
 201775c:	92 10 00 1b 	mov  %i3, %o1                                  
 2017760:	94 07 bf 80 	add  %fp, -128, %o2                            
 2017764:	40 00 01 45 	call  2017c78 <msdos_long_to_short>            
 2017768:	96 10 20 0b 	mov  0xb, %o3                                  
                                     MSDOS_DIR_NAME(short_node),      
                                     MSDOS_NAME_MAX);                 
    if (name_type == MSDOS_NAME_INVALID) {                            
 201776c:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 2017770:	32 80 00 08 	bne,a   2017790 <msdos_creat_node+0xa0>        <== ALWAYS TAKEN
 2017774:	c0 2f bf 8c 	clrb  [ %fp + -116 ]                           
        rtems_set_errno_and_return_minus_one(EINVAL);                 
 2017778:	40 00 0f 8d 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201777c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2017780:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
 2017784:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2017788:	10 80 00 ce 	b  2017ac0 <msdos_creat_node+0x3d0>            <== NOT EXECUTED
 201778c:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
                                                                      
    /* fill reserved field */                                         
    *MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;               
                                                                      
    /* set up last write date and time */                             
    time_ret = time(NULL);                                            
 2017790:	40 00 23 07 	call  20203ac <time>                           
 2017794:	90 10 20 00 	clr  %o0                                       
    if ( time_ret == -1 )                                             
 2017798:	80 a2 3f ff 	cmp  %o0, -1                                   
 201779c:	12 80 00 04 	bne  20177ac <msdos_creat_node+0xbc>           <== ALWAYS TAKEN
 20177a0:	92 07 bf 6a 	add  %fp, -150, %o1                            
 20177a4:	10 80 00 c7 	b  2017ac0 <msdos_creat_node+0x3d0>            <== NOT EXECUTED
 20177a8:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
 20177ac:	40 00 0b bd 	call  201a6a0 <msdos_date_unix2dos>            
 20177b0:	94 07 bf 68 	add  %fp, -152, %o2                            
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
 20177b4:	c2 17 bf 68 	lduh  [ %fp + -152 ], %g1                      
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
 20177b8:	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);              
 20177bc:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 20177c0:	85 30 60 08 	srl  %g1, 8, %g2                               
 20177c4:	83 30 60 18 	srl  %g1, 0x18, %g1                            
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
 20177c8:	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);              
 20177cc:	84 10 80 01 	or  %g2, %g1, %g2                              
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
    *MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);                
    *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);          
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
 20177d0:	c0 27 bf 9c 	clr  [ %fp + -100 ]                            
    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);                  
 20177d4:	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);              
 20177d8:	c4 37 bf 8e 	sth  %g2, [ %fp + -114 ]                       
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
 20177dc:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
    *MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);            
 20177e0:	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);                  
 20177e4:	82 10 40 03 	or  %g1, %g3, %g1                              
 20177e8:	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);                
 20177ec:	c2 37 bf 98 	sth  %g1, [ %fp + -104 ]                       
    *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);          
                                                                      
    /* initialize directory/file size */                              
    *MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;           
                                                                      
    if (type == MSDOS_DIRECTORY) {                                    
 20177f0:	80 a6 60 00 	cmp  %i1, 0                                    
 20177f4:	12 80 00 05 	bne  2017808 <msdos_creat_node+0x118>          
 20177f8:	c2 37 bf 92 	sth  %g1, [ %fp + -110 ]                       
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
 20177fc:	c2 0f bf 8b 	ldub  [ %fp + -117 ], %g1                      
 2017800:	10 80 00 2f 	b  20178bc <msdos_creat_node+0x1cc>            
 2017804:	82 10 60 10 	or  %g1, 0x10, %g1                             
    }                                                                 
    else if (type == MSDOS_HARD_LINK) {                               
 2017808:	80 a6 60 02 	cmp  %i1, 2                                    
 201780c:	12 80 00 2b 	bne  20178b8 <msdos_creat_node+0x1c8>          <== ALWAYS TAKEN
 2017810:	c2 0f bf 8b 	ldub  [ %fp + -117 ], %g1                      
       * node to the newly created                                    
       */                                                             
      /*                                                              
       * read the original directory entry                            
       */                                                             
      sec = fat_cluster_num_to_sector_num(&fs_info->fat,              
 2017814:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        <== 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)) )
 2017818:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
 201781c:	32 80 00 08 	bne,a   201783c <msdos_creat_node+0x14c>       <== NOT EXECUTED
 2017820:	c2 0f 20 05 	ldub  [ %i4 + 5 ], %g1                         <== NOT EXECUTED
 2017824:	c2 0f 20 0e 	ldub  [ %i4 + 0xe ], %g1                       <== NOT EXECUTED
 2017828:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
 201782c:	22 80 00 04 	be,a   201783c <msdos_creat_node+0x14c>        <== NOT EXECUTED
 2017830:	c2 0f 20 05 	ldub  [ %i4 + 5 ], %g1                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
 2017834:	10 80 00 06 	b  201784c <msdos_creat_node+0x15c>            <== NOT EXECUTED
 2017838:	c4 07 20 20 	ld  [ %i4 + 0x20 ], %g2                        <== NOT EXECUTED
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
 201783c:	84 00 bf fe 	add  %g2, -2, %g2                              <== NOT EXECUTED
 2017840:	85 28 80 01 	sll  %g2, %g1, %g2                             <== NOT EXECUTED
 2017844:	c2 07 20 34 	ld  [ %i4 + 0x34 ], %g1                        <== NOT EXECUTED
 2017848:	84 00 80 01 	add  %g2, %g1, %g2                             <== NOT EXECUTED
                                          link_fd->dir_pos.sname.cln);
      sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
 201784c:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        <== NOT EXECUTED
 2017850:	d2 0f 20 02 	ldub  [ %i4 + 2 ], %o1                         <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
 2017854:	d4 17 00 00 	lduh  [ %i4 ], %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);
 2017858:	93 30 40 09 	srl  %g1, %o1, %o1                             <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
 201785c:	94 02 bf ff 	add  %o2, -1, %o2                              <== NOT EXECUTED
                                                                      
      ret = _fat_block_read(&fs_info->fat,                            
 2017860:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 2017864:	92 00 80 09 	add  %g2, %o1, %o1                             <== NOT EXECUTED
 2017868:	94 0a 80 01 	and  %o2, %g1, %o2                             <== NOT EXECUTED
 201786c:	96 10 20 20 	mov  0x20, %o3                                 <== NOT EXECUTED
 2017870:	7f ff ed e4 	call  2013000 <_fat_block_read>                <== NOT EXECUTED
 2017874:	98 07 bf a0 	add  %fp, -96, %o4                             <== NOT EXECUTED
                            sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
                            link_node);                               
      if (ret < 0) {                                                  
 2017878:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201787c:	06 bf ff c3 	bl  2017788 <msdos_creat_node+0x98>            <== NOT EXECUTED
 2017880:	c2 0f bf ad 	ldub  [ %fp + -83 ], %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);
 2017884:	c2 2f bf 8d 	stb  %g1, [ %fp + -115 ]                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_TIME(short_node)      =*MSDOS_DIR_CRT_TIME(link_node);
 2017888:	c2 17 bf ae 	lduh  [ %fp + -82 ], %g1                       <== NOT EXECUTED
 201788c:	c2 37 bf 8e 	sth  %g1, [ %fp + -114 ]                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
 2017890:	c2 17 bf b0 	lduh  [ %fp + -80 ], %g1                       <== NOT EXECUTED
 2017894:	c2 37 bf 90 	sth  %g1, [ %fp + -112 ]                       <== NOT EXECUTED
                                                                      
      /*                                                              
       * copy/set "file size", "first cluster"                        
       */                                                             
      *MSDOS_DIR_FILE_SIZE(short_node)     =*MSDOS_DIR_FILE_SIZE(link_node);
 2017898:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         <== NOT EXECUTED
 201789c:	c2 27 bf 9c 	st  %g1, [ %fp + -100 ]                        <== NOT EXECUTED
                                                                      
      *MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =                      
 20178a0:	c2 17 bf ba 	lduh  [ %fp + -70 ], %g1                       <== NOT EXECUTED
 20178a4:	c2 37 bf 9a 	sth  %g1, [ %fp + -102 ]                       <== NOT EXECUTED
           *MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);                   
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
 20178a8:	c2 17 bf b4 	lduh  [ %fp + -76 ], %g1                       <== NOT EXECUTED
 20178ac:	c2 37 bf 94 	sth  %g1, [ %fp + -108 ]                       <== NOT EXECUTED
           *MSDOS_DIR_FIRST_CLUSTER_HI(link_node);                    
      /*                                                              
       * set "archive bit" due to changes                             
       */                                                             
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;              
 20178b0:	10 80 00 02 	b  20178b8 <msdos_creat_node+0x1c8>            <== NOT EXECUTED
 20178b4:	c2 0f bf ab 	ldub  [ %fp + -85 ], %g1                       <== NOT EXECUTED
    }                                                                 
    else { /* regular file... */                                      
        *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;            
 20178b8:	82 10 60 20 	or  %g1, 0x20, %g1                             
 20178bc:	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,        
                             name_type, &dir_pos, short_node);        
 20178c0:	a2 07 bf 80 	add  %fp, -128, %l1                            
                                                                      
    /*                                                                
     * 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,        
 20178c4:	90 10 00 18 	mov  %i0, %o0                                  
 20178c8:	e2 23 a0 5c 	st  %l1, [ %sp + 0x5c ]                        
 20178cc:	92 10 20 01 	mov  1, %o1                                    
 20178d0:	94 10 00 1a 	mov  %i2, %o2                                  
 20178d4:	96 10 00 1b 	mov  %i3, %o3                                  
 20178d8:	98 10 00 12 	mov  %l2, %o4                                  
 20178dc:	40 00 05 fc 	call  20190cc <msdos_get_name_node>            
 20178e0:	9a 07 bf 70 	add  %fp, -144, %o5                            
                             name_type, &dir_pos, short_node);        
    if ( rc != RC_OK )                                                
 20178e4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20178e8:	12 80 00 76 	bne  2017ac0 <msdos_creat_node+0x3d0>          
 20178ec:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
    /*                                                                
     * if we create a new file we are done, if directory there are more steps
     * to do                                                          
     */                                                               
    if (type == MSDOS_DIRECTORY)                                      
 20178f0:	32 80 00 75 	bne,a   2017ac4 <msdos_creat_node+0x3d4>       
 20178f4:	b0 10 00 1d 	mov  %i5, %i0                                  
    {                                                                 
        /* open new directory as fat-file */                          
        rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);         
 20178f8:	90 10 00 1c 	mov  %i4, %o0                                  
 20178fc:	92 07 bf 70 	add  %fp, -144, %o1                            
 2017900:	7f ff ea 22 	call  2012188 <fat_file_open>                  
 2017904:	94 07 bf 6c 	add  %fp, -148, %o2                            
        if (rc != RC_OK)                                              
 2017908:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201790c:	32 80 00 6a 	bne,a   2017ab4 <msdos_creat_node+0x3c4>       <== NEVER TAKEN
 2017910:	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;                                    
 2017914:	fa 07 bf 6c 	ld  [ %fp + -148 ], %i5                        
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
 2017918:	03 00 08 00 	sethi  %hi(0x200000), %g1                      
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
 201791c:	92 10 00 11 	mov  %l1, %o1                                  
         * 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;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
 2017920:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
 2017924:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
        /*                                                            
         * we opened fat-file for node we just created, so initialize fat-file
         * descritor                                                  
         */                                                           
        fat_fd->fat_file_size = 0;                                    
 2017928:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
 201792c:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
 2017930:	40 00 11 de 	call  201c0a8 <memcpy>                         
 2017934:	90 07 bf c0 	add  %fp, -64, %o0                             
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
 2017938:	92 10 00 11 	mov  %l1, %o1                                  
 201793c:	94 10 20 20 	mov  0x20, %o2                                 
 2017940:	40 00 11 da 	call  201c0a8 <memcpy>                         
 2017944:	90 07 bf e0 	add  %fp, -32, %o0                             
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
 2017948:	03 00 80 af 	sethi  %hi(0x202bc00), %g1                     
 201794c:	d2 00 60 dc 	ld  [ %g1 + 0xdc ], %o1	! 202bcdc <MSDOS_DOT_NAME>
 2017950:	94 10 20 0b 	mov  0xb, %o2                                  
 2017954:	40 00 11 d5 	call  201c0a8 <memcpy>                         
 2017958:	90 07 bf c0 	add  %fp, -64, %o0                             
               MSDOS_NAME_MAX);                                       
        memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
 201795c:	03 00 80 af 	sethi  %hi(0x202bc00), %g1                     
 2017960:	d2 00 60 d8 	ld  [ %g1 + 0xd8 ], %o1	! 202bcd8 <MSDOS_DOTDOT_NAME>
 2017964:	90 07 bf e0 	add  %fp, -32, %o0                             
 2017968:	40 00 11 d0 	call  201c0a8 <memcpy>                         
 201796c:	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)) &&                    
 2017970:	c2 04 20 20 	ld  [ %l0 + 0x20 ], %g1                        
 2017974:	80 a0 60 01 	cmp  %g1, 1                                    
 2017978:	32 80 00 0e 	bne,a   20179b0 <msdos_creat_node+0x2c0>       
 201797c:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 2017980:	c2 04 20 24 	ld  [ %l0 + 0x24 ], %g1                        
 2017984:	80 a0 60 00 	cmp  %g1, 0                                    
 2017988:	32 80 00 0a 	bne,a   20179b0 <msdos_creat_node+0x2c0>       <== NEVER TAKEN
 201798c:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
            (fs_info->fat.vol.type & FAT_FAT32))                      
 2017990:	c2 0f 20 0e 	ldub  [ %i4 + 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)) &&                    
 2017994:	82 08 60 04 	and  %g1, 4, %g1                               
 2017998:	80 88 60 ff 	btst  0xff, %g1                                
 201799c:	22 80 00 05 	be,a   20179b0 <msdos_creat_node+0x2c0>        <== ALWAYS TAKEN
 20179a0:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
            (fs_info->fat.vol.type & FAT_FAT32))                      
        {                                                             
            *MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
 20179a4:	c0 37 bf fa 	clrh  [ %fp + -6 ]                             <== NOT EXECUTED
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
 20179a8:	10 80 00 10 	b  20179e8 <msdos_creat_node+0x2f8>            <== NOT EXECUTED
 20179ac:	c0 37 bf f4 	clrh  [ %fp + -12 ]                            <== 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);
    return rc;                                                        
}                                                                     
 20179b0:	05 00 00 3f 	sethi  %hi(0xfc00), %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)) = 
 20179b4:	87 28 60 10 	sll  %g1, 0x10, %g3                            
                                                                      
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;                                                        
}                                                                     
 20179b8:	84 10 a3 ff 	or  %g2, 0x3ff, %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)) = 
 20179bc:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
                                                                      
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;                                                        
}                                                                     
 20179c0:	88 08 40 02 	and  %g1, %g2, %g4                             
        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));
 20179c4:	83 30 60 10 	srl  %g1, 0x10, %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));
 20179c8:	89 29 20 08 	sll  %g4, 8, %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;                                                        
}                                                                     
 20179cc:	84 08 40 02 	and  %g1, %g2, %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)) = 
 20179d0:	86 11 00 03 	or  %g4, %g3, %g3                              
                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));
 20179d4:	85 28 a0 08 	sll  %g2, 8, %g2                               
        }                                                             
        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)) =  
 20179d8:	83 30 60 08 	srl  %g1, 8, %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)) = 
 20179dc:	c6 37 bf fa 	sth  %g3, [ %fp + -6 ]                         
                CT_LE_W((uint16_t  )((parent_fat_fd->cln) & 0x0000FFFF));
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =  
 20179e0:	82 10 80 01 	or  %g2, %g1, %g1                              
 20179e4:	c2 37 bf f4 	sth  %g1, [ %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,                
 20179e8:	90 10 00 1c 	mov  %i4, %o0                                  
 20179ec:	92 10 00 1d 	mov  %i5, %o1                                  
 20179f0:	94 10 20 00 	clr  %o2                                       
 20179f4:	96 10 20 40 	mov  0x40, %o3                                 
 20179f8:	7f ff eb f1 	call  20129bc <fat_file_write>                 
 20179fc:	98 07 bf c0 	add  %fp, -64, %o4                             
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,   
                             (uint8_t *)dot_dotdot);                  
        if (ret < 0)                                                  
 2017a00:	80 a2 20 00 	cmp  %o0, 0                                    
 2017a04:	06 80 00 27 	bl  2017aa0 <msdos_creat_node+0x3b0>           <== NEVER TAKEN
 2017a08:	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;                
 2017a0c:	c2 17 20 06 	lduh  [ %i4 + 6 ], %g1                         
 2017a10:	c4 02 60 18 	ld  [ %o1 + 0x18 ], %g2                        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
                                                                      
        /* rewrite dot entry */                                       
        ret = fat_file_write(&fs_info->fat, fat_fd, 0,                
 2017a14:	90 10 00 1c 	mov  %i4, %o0                                  
            rc = -1;                                                  
            goto error;                                               
        }                                                             
                                                                      
        /* increment fat-file size by cluster size */                 
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
 2017a18:	82 00 80 01 	add  %g2, %g1, %g1                             
 2017a1c:	c2 22 60 18 	st  %g1, [ %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));    
 2017a20:	c2 02 60 1c 	ld  [ %o1 + 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;                                                        
}                                                                     
 2017a24:	05 00 00 3f 	sethi  %hi(0xfc00), %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)) =        
 2017a28:	87 28 60 10 	sll  %g1, 0x10, %g3                            
                                                                      
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;                                                        
}                                                                     
 2017a2c:	84 10 a3 ff 	or  %g2, 0x3ff, %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)) =        
 2017a30:	87 30 e0 18 	srl  %g3, 0x18, %g3                            
                                                                      
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;                                                        
}                                                                     
 2017a34:	88 08 40 02 	and  %g1, %g2, %g4                             
                                                                      
        /* 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)) =         
                CT_LE_W((uint16_t  )(((fat_fd->cln) & 0xFFFF0000) >> 16));
 2017a38:	83 30 60 10 	srl  %g1, 0x10, %g1                            
        /* 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));    
 2017a3c:	89 29 20 08 	sll  %g4, 8, %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;                                                        
}                                                                     
 2017a40:	84 08 40 02 	and  %g1, %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)) =        
 2017a44:	86 11 00 03 	or  %g4, %g3, %g3                              
                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));
 2017a48:	85 28 a0 08 	sll  %g2, 8, %g2                               
        fat_fd->fat_file_size += fs_info->fat.vol.bpc;                
                                                                      
        /* set up cluster num for dot entry */                        
        *MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
 2017a4c:	83 30 60 08 	srl  %g1, 8, %g1                               
 2017a50:	82 10 80 01 	or  %g2, %g1, %g1                              
                                                                      
        /* 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)) =        
 2017a54:	c6 37 bf da 	sth  %g3, [ %fp + -38 ]                        
                CT_LE_W((uint16_t  )((fat_fd->cln) & 0x0000FFFF));    
        *MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =         
 2017a58:	c2 37 bf d4 	sth  %g1, [ %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,                
 2017a5c:	94 10 20 00 	clr  %o2                                       
 2017a60:	96 10 20 20 	mov  0x20, %o3                                 
 2017a64:	7f ff eb d6 	call  20129bc <fat_file_write>                 
 2017a68:	98 07 bf c0 	add  %fp, -64, %o4                             
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,       
                             (uint8_t *)DOT_NODE_P(dot_dotdot));      
        if (ret < 0)                                                  
 2017a6c:	80 a2 20 00 	cmp  %o0, 0                                    
 2017a70:	06 80 00 0d 	bl  2017aa4 <msdos_creat_node+0x3b4>           <== NEVER TAKEN
 2017a74:	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);
 2017a78:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
 2017a7c:	40 00 01 45 	call  2017f90 <msdos_set_first_cluster_num>    
 2017a80:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
        if (rc != RC_OK)                                              
 2017a84:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2017a88:	12 80 00 08 	bne  2017aa8 <msdos_creat_node+0x3b8>          <== NEVER TAKEN
 2017a8c:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
            goto error;                                               
                                                                      
        fat_file_close(&fs_info->fat, fat_fd);                        
 2017a90:	7f ff ea d4 	call  20125e0 <fat_file_close>                 
 2017a94:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
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;                                                        
}                                                                     
 2017a98:	81 c7 e0 08 	ret                                            
 2017a9c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
        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;                                                  
 2017aa0:	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);                            
 2017aa4:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        <== NOT EXECUTED
 2017aa8:	7f ff ea ce 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 2017aac:	90 10 00 1c 	mov  %i4, %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);
 2017ab0:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        <== NOT EXECUTED
 2017ab4:	92 07 bf 70 	add  %fp, -144, %o1                            <== NOT EXECUTED
 2017ab8:	40 00 01 81 	call  20180bc <msdos_set_first_char4file_name> <== NOT EXECUTED
 2017abc:	94 10 20 e5 	mov  0xe5, %o2                                 <== NOT EXECUTED
    return rc;                                                        
}                                                                     
 2017ac0:	b0 10 00 1d 	mov  %i5, %i0                                  
 2017ac4:	81 c7 e0 08 	ret                                            
 2017ac8:	81 e8 00 00 	restore                                        
                                                                      

0201a7ec <msdos_date_dos2unix>: 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;
 201a7ec:	85 32 60 0b 	srl  %o1, 0xb, %g2                             
 201a7f0:	84 08 a0 1f 	and  %g2, 0x1f, %g2                            
 201a7f4:	87 28 a0 03 	sll  %g2, 3, %g3                               
 201a7f8:	83 28 a0 07 	sll  %g2, 7, %g1                               
 201a7fc:	82 20 40 03 	sub  %g1, %g3, %g1                             
 201a800:	85 28 60 04 	sll  %g1, 4, %g2                               
 201a804:	84 20 80 01 	sub  %g2, %g1, %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  
 201a808:	82 0a 67 e0 	and  %o1, 0x7e0, %g1                           
 201a80c:	87 30 60 04 	srl  %g1, 4, %g3                               
 201a810:	82 20 40 03 	sub  %g1, %g3, %g1                             
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
 201a814:	82 00 80 01 	add  %g2, %g1, %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)
 201a818:	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;   
 201a81c:	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) {                                             
 201a820:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a824:	c4 10 63 3a 	lduh  [ %g1 + 0x33a ], %g2	! 202d73a <lastdosdate>
 201a828:	80 a0 80 08 	cmp  %g2, %o0                                  
 201a82c:	02 80 00 34 	be  201a8fc <msdos_date_dos2unix+0x110>        
 201a830:	93 2a 60 01 	sll  %o1, 1, %o1                               
		lastdosdate = dd;                                                   
 201a834:	d0 30 63 3a 	sth  %o0, [ %g1 + 0x33a ]                      
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
 201a838:	89 32 20 09 	srl  %o0, 9, %g4                               
	 * If the year, month, and day from the last conversion are the      
	 * same then use the saved value.                                    
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
 201a83c:	82 10 20 00 	clr  %g1                                       
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
 201a840:	88 09 20 7f 	and  %g4, 0x7f, %g4                            
		for (y = 0; y < year; y++)                                          
 201a844:	10 80 00 07 	b  201a860 <msdos_date_dos2unix+0x74>          
 201a848:	84 10 20 00 	clr  %g2                                       
			days += y & 0x03 ? 365 : 366;                                      
 201a84c:	80 a0 00 03 	cmp  %g0, %g3                                  
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
 201a850:	84 00 a0 01 	inc  %g2                                       
			days += y & 0x03 ? 365 : 366;                                      
 201a854:	86 60 3f ff 	subx  %g0, -1, %g3                             
 201a858:	86 00 e1 6d 	add  %g3, 0x16d, %g3                           
 201a85c:	82 00 40 03 	add  %g1, %g3, %g1                             
	 */                                                                  
	if (lastdosdate != dd) {                                             
		lastdosdate = dd;                                                   
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
 201a860:	80 a0 80 04 	cmp  %g2, %g4                                  
 201a864:	12 bf ff fa 	bne  201a84c <msdos_date_dos2unix+0x60>        
 201a868:	86 08 a0 03 	and  %g2, 3, %g3                               
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
 201a86c:	80 a0 e0 00 	cmp  %g3, 0                                    
 201a870:	22 80 00 05 	be,a   201a884 <msdos_date_dos2unix+0x98>      <== ALWAYS TAKEN
 201a874:	09 00 80 b3 	sethi  %hi(0x202cc00), %g4                     
 201a878:	09 00 80 b3 	sethi  %hi(0x202cc00), %g4                     <== NOT EXECUTED
 201a87c:	10 80 00 03 	b  201a888 <msdos_date_dos2unix+0x9c>          <== NOT EXECUTED
 201a880:	88 11 23 d8 	or  %g4, 0x3d8, %g4	! 202cfd8 <regyear>        <== NOT EXECUTED
 201a884:	88 11 23 f0 	or  %g4, 0x3f0, %g4                            
		/*                                                                  
		 * Prevent going from 0 to 0xffffffff in the following              
		 * loop.                                                            
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
 201a888:	86 0a 21 e0 	and  %o0, 0x1e0, %g3                           
 201a88c:	87 30 e0 05 	srl  %g3, 5, %g3                               
		if (month == 0) {                                                   
 201a890:	80 a0 e0 00 	cmp  %g3, 0                                    
 201a894:	22 80 00 02 	be,a   201a89c <msdos_date_dos2unix+0xb0>      <== NEVER TAKEN
 201a898:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
 201a89c:	84 10 20 00 	clr  %g2                                       
 201a8a0:	10 80 00 05 	b  201a8b4 <msdos_date_dos2unix+0xc8>          
 201a8a4:	86 00 ff ff 	add  %g3, -1, %g3                              
			days += months[m];                                                 
 201a8a8:	da 11 00 0d 	lduh  [ %g4 + %o5 ], %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++)                                     
 201a8ac:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
			days += months[m];                                                 
 201a8b0:	82 00 40 0d 	add  %g1, %o5, %g1                             <== NOT EXECUTED
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
		if (month == 0) {                                                   
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
 201a8b4:	80 a0 80 03 	cmp  %g2, %g3                                  
 201a8b8:	0a bf ff fc 	bcs  201a8a8 <msdos_date_dos2unix+0xbc>        <== NEVER TAKEN
 201a8bc:	9b 28 a0 01 	sll  %g2, 1, %o5                               
			days += months[m];                                                 
		days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;       
 201a8c0:	90 0a 20 1f 	and  %o0, 0x1f, %o0                            
 201a8c4:	90 02 3f ff 	add  %o0, -1, %o0                              
 201a8c8:	82 02 00 01 	add  %o0, %g1, %g1                             
		lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;                  
 201a8cc:	85 28 60 07 	sll  %g1, 7, %g2                               
 201a8d0:	83 28 60 09 	sll  %g1, 9, %g1                               
 201a8d4:	82 20 40 02 	sub  %g1, %g2, %g1                             
 201a8d8:	85 28 60 04 	sll  %g1, 4, %g2                               
 201a8dc:	82 20 80 01 	sub  %g2, %g1, %g1                             
 201a8e0:	85 28 60 04 	sll  %g1, 4, %g2                               
 201a8e4:	82 20 80 01 	sub  %g2, %g1, %g1                             
 201a8e8:	05 04 b3 a9 	sethi  %hi(0x12cea400), %g2                    
 201a8ec:	84 10 a2 00 	or  %g2, 0x200, %g2	! 12cea600 <RAM_END+0x108ea600>
 201a8f0:	82 00 40 02 	add  %g1, %g2, %g1                             
 201a8f4:	05 00 80 b5 	sethi  %hi(0x202d400), %g2                     
 201a8f8:	c2 20 a3 3c 	st  %g1, [ %g2 + 0x33c ]	! 202d73c <lastseconds>
	}                                                                    
	return seconds + lastseconds;                                        
 201a8fc:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a900:	d0 00 63 3c 	ld  [ %g1 + 0x33c ], %o0	! 202d73c <lastseconds>
}                                                                     
 201a904:	81 c3 e0 08 	retl                                           
 201a908:	90 02 40 08 	add  %o1, %o0, %o0                             
                                                                      

0201a6a0 <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) {
 201a6a0:	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) {                                                 
 201a6a4:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a6a8:	c4 00 63 2c 	ld  [ %g1 + 0x32c ], %g2	! 202d72c <lasttime>  
 201a6ac:	80 a0 80 18 	cmp  %g2, %i0                                  
 201a6b0:	02 80 00 47 	be  201a7cc <msdos_date_unix2dos+0x12c>        
 201a6b4:	92 10 20 3c 	mov  0x3c, %o1                                 
		lasttime = t;                                                       
 201a6b8:	f0 20 63 2c 	st  %i0, [ %g1 + 0x32c ]                       
		lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)            
		    + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)                   
 201a6bc:	7f ff a0 1f 	call  2002738 <.udiv>                          
 201a6c0:	90 10 00 18 	mov  %i0, %o0                                  
 201a6c4:	40 00 39 26 	call  2028b5c <.urem>                          
 201a6c8:	92 10 20 3c 	mov  0x3c, %o1                                 
		    + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);                  
 201a6cc:	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)            
 201a6d0:	bb 2a 20 05 	sll  %o0, 5, %i5                               
		    + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)                   
		    + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);                  
 201a6d4:	7f ff a0 19 	call  2002738 <.udiv>                          
 201a6d8:	90 10 00 18 	mov  %i0, %o0                                  
 201a6dc:	40 00 39 20 	call  2028b5c <.urem>                          
 201a6e0:	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)            
 201a6e4:	91 2a 20 0b 	sll  %o0, 0xb, %o0                             
 201a6e8:	92 10 20 3c 	mov  0x3c, %o1                                 
 201a6ec:	ba 07 40 08 	add  %i5, %o0, %i5                             
 201a6f0:	40 00 39 1b 	call  2028b5c <.urem>                          
 201a6f4:	90 10 00 18 	mov  %i0, %o0                                  
 201a6f8:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a6fc:	91 32 20 01 	srl  %o0, 1, %o0                               
		/*                                                                  
		 * 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);                                         
 201a700:	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)            
 201a704:	ba 07 40 08 	add  %i5, %o0, %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);                                         
 201a708:	92 12 61 80 	or  %o1, 0x180, %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)            
 201a70c:	fa 30 63 30 	sth  %i5, [ %g1 + 0x330 ]                      
		/*                                                                  
		 * 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);                                         
 201a710:	7f ff a0 0a 	call  2002738 <.udiv>                          
 201a714:	90 10 00 18 	mov  %i0, %o0                                  
		if (days != lastday) {                                              
 201a718:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a71c:	c4 00 63 34 	ld  [ %g1 + 0x334 ], %g2	! 202d734 <lastday>   
 201a720:	80 a2 00 02 	cmp  %o0, %g2                                  
 201a724:	22 80 00 2b 	be,a   201a7d0 <msdos_date_unix2dos+0x130>     
 201a728:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
			lastday = days;                                                    
 201a72c:	d0 20 63 34 	st  %o0, [ %g1 + 0x334 ]	! 202d734 <lastday>   
			for (year = 1970;; year++) {                                       
 201a730:	82 10 27 b2 	mov  0x7b2, %g1                                
				inc = year & 0x03 ? 365 : 366;                                    
 201a734:	84 08 60 03 	and  %g1, 3, %g2                               
 201a738:	80 a0 00 02 	cmp  %g0, %g2                                  
 201a73c:	86 60 3f ff 	subx  %g0, -1, %g3                             
 201a740:	86 00 e1 6d 	add  %g3, 0x16d, %g3                           
				if (days < inc)                                                   
 201a744:	80 a2 00 03 	cmp  %o0, %g3                                  
 201a748:	0a 80 00 05 	bcs  201a75c <msdos_date_unix2dos+0xbc>        
 201a74c:	80 a0 a0 00 	cmp  %g2, 0                                    
					break;                                                           
				days -= inc;                                                      
 201a750:	90 22 00 03 	sub  %o0, %g3, %o0                             
			}                                                                  
 201a754:	10 bf ff f8 	b  201a734 <msdos_date_unix2dos+0x94>          
 201a758:	82 00 60 01 	inc  %g1                                       
			months = year & 0x03 ? regyear : leapyear;                         
 201a75c:	22 80 00 05 	be,a   201a770 <msdos_date_unix2dos+0xd0>      <== ALWAYS TAKEN
 201a760:	09 00 80 b3 	sethi  %hi(0x202cc00), %g4                     
 201a764:	09 00 80 b3 	sethi  %hi(0x202cc00), %g4                     <== NOT EXECUTED
 201a768:	10 80 00 03 	b  201a774 <msdos_date_unix2dos+0xd4>          <== NOT EXECUTED
 201a76c:	88 11 23 d8 	or  %g4, 0x3d8, %g4	! 202cfd8 <regyear>        <== NOT EXECUTED
 201a770:	88 11 23 f0 	or  %g4, 0x3f0, %g4                            
			for (month = 0; month < 12; month++) {                             
 201a774:	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,                    
 201a778:	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])                                         
 201a77c:	c6 11 00 03 	lduh  [ %g4 + %g3 ], %g3                       
 201a780:	80 a2 00 03 	cmp  %o0, %g3                                  
 201a784:	2a 80 00 07 	bcs,a   201a7a0 <msdos_date_unix2dos+0x100>    <== ALWAYS TAKEN
 201a788:	90 02 20 01 	inc  %o0                                       
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
			for (month = 0; month < 12; month++) {                             
 201a78c:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
 201a790:	80 a0 a0 0c 	cmp  %g2, 0xc                                  <== NOT EXECUTED
 201a794:	12 bf ff f9 	bne  201a778 <msdos_date_unix2dos+0xd8>        <== NOT EXECUTED
 201a798:	90 22 00 03 	sub  %o0, %g3, %o0                             <== NOT EXECUTED
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
 201a79c:	90 02 20 01 	inc  %o0                                       <== NOT EXECUTED
 201a7a0:	84 00 a0 01 	inc  %g2                                       
 201a7a4:	07 00 80 b5 	sethi  %hi(0x202d400), %g3                     
 201a7a8:	85 28 a0 05 	sll  %g2, 5, %g2                               
 201a7ac:	90 02 00 02 	add  %o0, %g2, %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)                                                   
 201a7b0:	80 a0 67 bc 	cmp  %g1, 0x7bc                                
 201a7b4:	08 80 00 06 	bleu  201a7cc <msdos_date_unix2dos+0x12c>      <== NEVER TAKEN
 201a7b8:	d0 30 e3 38 	sth  %o0, [ %g3 + 0x338 ]                      
				lastddate += (year - 1980) <<                                     
 201a7bc:	82 00 78 44 	add  %g1, -1980, %g1                           
 201a7c0:	83 28 60 09 	sll  %g1, 9, %g1                               
 201a7c4:	90 02 00 01 	add  %o0, %g1, %o0                             
 201a7c8:	d0 30 e3 38 	sth  %o0, [ %g3 + 0x338 ]                      
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
 201a7cc:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a7d0:	c2 10 63 30 	lduh  [ %g1 + 0x330 ], %g1	! 202d730 <lastdtime>
 201a7d4:	c2 36 80 00 	sth  %g1, [ %i2 ]                              
	*ddp = lastddate;                                                    
 201a7d8:	03 00 80 b5 	sethi  %hi(0x202d400), %g1                     
 201a7dc:	c2 10 63 38 	lduh  [ %g1 + 0x338 ], %g1	! 202d738 <lastddate>
 201a7e0:	c2 36 40 00 	sth  %g1, [ %i1 ]                              
 201a7e4:	81 c7 e0 08 	ret                                            
 201a7e8:	81 e8 00 00 	restore                                        
                                                                      

020181f0 <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 ) {
 20181f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
             */                                                       
            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,     
 20181f4:	23 00 80 af 	sethi  %hi(0x202bc00), %l1                     
    fat_file_fd_t                        *fat_fd,                     
    bool                                 *ret_val                     
    )                                                                 
{                                                                     
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
 20181f8:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
 20181fc:	25 00 80 af 	sethi  %hi(0x202bc00), %l2                     
    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;                                                 
 2018200:	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;                                    
 2018204:	b6 10 20 00 	clr  %i3                                       
             */                                                       
            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,     
 2018208:	a2 14 60 98 	or  %l1, 0x98, %l1                             
    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,
 201820c:	10 80 00 33 	b  20182d8 <msdos_dir_is_empty+0xe8>           
 2018210:	a4 14 a0 a8 	or  %l2, 0xa8, %l2                             
                                  fs_info->fat.vol.bps,               
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
 2018214:	04 80 00 2a 	ble  20182bc <msdos_dir_is_empty+0xcc>         <== NEVER TAKEN
 2018218:	b0 10 3f ff 	mov  -1, %i0                                   
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
 201821c:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
 2018220:	80 a2 00 01 	cmp  %o0, %g1                                  
 2018224:	02 80 00 28 	be  20182c4 <msdos_dir_is_empty+0xd4>          <== ALWAYS TAKEN
 2018228:	b8 10 20 00 	clr  %i4                                       
 201822c:	11 00 80 af 	sethi  %hi(0x202bc00), %o0                     <== NOT EXECUTED
 2018230:	15 00 80 af 	sethi  %hi(0x202bc00), %o2                     <== NOT EXECUTED
 2018234:	17 00 80 af 	sethi  %hi(0x202bc00), %o3                     <== NOT EXECUTED
 2018238:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
 201823c:	92 10 23 65 	mov  0x365, %o1                                <== NOT EXECUTED
 2018240:	94 12 a0 e0 	or  %o2, 0xe0, %o2                             <== NOT EXECUTED
 2018244:	7f ff f1 36 	call  201471c <__assert_func>                  <== NOT EXECUTED
 2018248:	96 12 e0 78 	or  %o3, 0x78, %o3                             <== NOT EXECUTED
             * then consider it as empty.                             
             *                                                        
             * Just ignore long file name entries. They must have a short entry to
             * be valid.                                              
             */                                                       
            if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                    
 201824c:	e0 08 40 1c 	ldub  [ %g1 + %i4 ], %l0                       
 2018250:	80 a4 20 e5 	cmp  %l0, 0xe5                                 
 2018254:	02 80 00 14 	be  20182a4 <msdos_dir_is_empty+0xb4>          <== NEVER TAKEN
 2018258:	b0 00 40 1c 	add  %g1, %i4, %i0                             
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
 201825c:	c2 0e 20 0b 	ldub  [ %i0 + 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) ||                       
 2018260:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
 2018264:	80 a0 60 0f 	cmp  %g1, 0xf                                  
 2018268:	02 80 00 0f 	be  20182a4 <msdos_dir_is_empty+0xb4>          <== NEVER TAKEN
 201826c:	90 10 00 18 	mov  %i0, %o0                                  
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
                 MSDOS_ATTR_LFN) ||                                   
                (strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,     
 2018270:	92 10 00 11 	mov  %l1, %o1                                  
 2018274:	40 00 16 0a 	call  201da9c <strncmp>                        
 2018278:	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) ||                                   
 201827c:	80 a2 20 00 	cmp  %o0, 0                                    
 2018280:	22 80 00 12 	be,a   20182c8 <msdos_dir_is_empty+0xd8>       
 2018284:	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)),                     
 2018288:	90 10 00 18 	mov  %i0, %o0                                  
 201828c:	92 10 00 12 	mov  %l2, %o1                                  
 2018290:	40 00 16 03 	call  201da9c <strncmp>                        
 2018294:	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) ||               
 2018298:	80 a2 20 00 	cmp  %o0, 0                                    
 201829c:	12 80 00 04 	bne  20182ac <msdos_dir_is_empty+0xbc>         
 20182a0:	80 a4 20 00 	cmp  %l0, 0                                    
        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)                  
 20182a4:	10 80 00 09 	b  20182c8 <msdos_dir_is_empty+0xd8>           
 20182a8:	b8 07 20 20 	add  %i4, 0x20, %i4                            
                continue;                                             
                                                                      
            /*                                                        
             * Nothing more to look at.                               
             */                                                       
            if ((*MSDOS_DIR_NAME(entry)) ==                           
 20182ac:	12 80 00 04 	bne  20182bc <msdos_dir_is_empty+0xcc>         
 20182b0:	b0 10 20 00 	clr  %i0                                       
                MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)                  
            {                                                         
                *ret_val = true;                                      
 20182b4:	82 10 20 01 	mov  1, %g1                                    
 20182b8:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
                return RC_OK;                                         
 20182bc:	81 c7 e0 08 	ret                                            
 20182c0:	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;                                
 20182c4:	a6 10 00 08 	mov  %o0, %l3                                  
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
 20182c8:	80 a7 00 13 	cmp  %i4, %l3                                  
 20182cc:	2a bf ff e0 	bcs,a   201824c <msdos_dir_is_empty+0x5c>      <== ALWAYS TAKEN
 20182d0:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
            /*                                                        
             * Short file name entries mean not empty.                
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
 20182d4:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
    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,
 20182d8:	f8 17 40 00 	lduh  [ %i5 ], %i4                             
 20182dc:	90 10 00 1b 	mov  %i3, %o0                                  
 20182e0:	7f ff a8 dc 	call  2002650 <.umul>                          
 20182e4:	92 10 00 1c 	mov  %i4, %o1                                  
 20182e8:	d8 07 60 a0 	ld  [ %i5 + 0xa0 ], %o4                        
 20182ec:	94 10 00 08 	mov  %o0, %o2                                  
 20182f0:	92 10 00 19 	mov  %i1, %o1                                  
 20182f4:	90 10 00 1d 	mov  %i5, %o0                                  
 20182f8:	7f ff e8 07 	call  2012314 <fat_file_read>                  
 20182fc:	96 10 00 1c 	mov  %i4, %o3                                  
 2018300:	80 a2 20 00 	cmp  %o0, 0                                    
 2018304:	32 bf ff c4 	bne,a   2018214 <msdos_dir_is_empty+0x24>      <== ALWAYS TAKEN
 2018308:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
    }                                                                 
    *ret_val = true;                                                  
 201830c:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2018310:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              <== NOT EXECUTED
 2018314:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    return RC_OK;                                                     
}                                                                     
 2018318:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201831c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201aa88 <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) {
 201aa88:	9d e3 be 68 	save  %sp, -408, %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;     
 201aa8c:	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);                      
 201aa90:	d0 1e 20 08 	ldd  [ %i0 + 8 ], %o0                          <== 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;     
 201aa94:	ec 00 60 08 	ld  [ %g1 + 8 ], %l6                           <== 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);                      
 201aa98:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201aa9c:	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)        
{                                                                     
 201aaa0:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== 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;                             
 201aaa4:	c0 27 be d0 	clr  [ %fp + -304 ]                            <== 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);                      
 201aaa8:	7f ff 9d ff 	call  20022a4 <__divdi3>                       <== NOT EXECUTED
 201aaac:	c0 27 be d4 	clr  [ %fp + -300 ]                            <== 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;            
 201aab0:	e0 06 20 1c 	ld  [ %i0 + 0x1c ], %l0                        <== 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);                      
 201aab4:	a6 10 00 09 	mov  %o1, %l3                                  <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
 201aab8:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 201aabc:	7f ff 9f 1f 	call  2002738 <.udiv>                          <== NOT EXECUTED
 201aac0:	92 10 21 18 	mov  0x118, %o1                                <== NOT EXECUTED
 201aac4:	a5 2a 20 03 	sll  %o0, 3, %l2                               <== NOT EXECUTED
 201aac8:	91 2a 20 05 	sll  %o0, 5, %o0                               <== NOT EXECUTED
 201aacc:	a4 04 80 08 	add  %l2, %o0, %l2                             <== NOT EXECUTED
 201aad0:	85 2c a0 03 	sll  %l2, 3, %g2                               <== NOT EXECUTED
 201aad4:	a4 20 80 12 	sub  %g2, %l2, %l2                             <== 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                              :     
 201aad8:	c4 04 20 20 	ld  [ %l0 + 0x20 ], %g2                        <== NOT EXECUTED
 201aadc:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
 201aae0:	32 80 00 0b 	bne,a   201ab0c <msdos_dir_read+0x84>          <== NOT EXECUTED
 201aae4:	ea 15 a0 06 	lduh  [ %l6 + 6 ], %l5                         <== 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) &&                           
 201aae8:	c4 04 20 24 	ld  [ %l0 + 0x24 ], %g2                        <== NOT EXECUTED
 201aaec:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
 201aaf0:	32 80 00 07 	bne,a   201ab0c <msdos_dir_read+0x84>          <== NOT EXECUTED
 201aaf4:	ea 15 a0 06 	lduh  [ %l6 + 6 ], %l5                         <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
 201aaf8:	c4 0d a0 0e 	ldub  [ %l6 + 0xe ], %g2                       <== 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) &&                           
 201aafc:	80 88 a0 03 	btst  3, %g2                                   <== NOT EXECUTED
 201ab00:	22 80 00 03 	be,a   201ab0c <msdos_dir_read+0x84>           <== NOT EXECUTED
 201ab04:	ea 15 a0 06 	lduh  [ %l6 + 6 ], %l5                         <== NOT EXECUTED
 201ab08:	ea 04 20 18 	ld  [ %l0 + 0x18 ], %l5                        <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
             fs_info->fat.vol.bpc;                                    
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 201ab0c:	d0 05 a0 9c 	ld  [ %l6 + 0x9c ], %o0                        <== NOT EXECUTED
 201ab10:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201ab14:	7f ff bb 5c 	call  2009884 <rtems_semaphore_obtain>         <== NOT EXECUTED
 201ab18:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201ab1c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201ab20:	22 80 00 fe 	be,a   201af18 <msdos_dir_read+0x490>          <== NOT EXECUTED
 201ab24:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
 201ab28:	30 80 00 0b 	b,a   201ab54 <msdos_dir_read+0xcc>            <== 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),      
 201ab2c:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
 201ab30:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 201ab34:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
 201ab38:	7f ff dd f7 	call  2012314 <fat_file_read>                  <== NOT EXECUTED
 201ab3c:	96 10 00 15 	mov  %l5, %o3                                  <== NOT EXECUTED
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
 201ab40:	80 a2 20 1f 	cmp  %o0, 0x1f                                 <== NOT EXECUTED
 201ab44:	14 80 00 ee 	bg  201aefc <msdos_dir_read+0x474>             <== NOT EXECUTED
 201ab48:	d0 27 be cc 	st  %o0, [ %fp + -308 ]                        <== NOT EXECUTED
        {                                                             
            rtems_semaphore_release(fs_info->vol_sema);               
 201ab4c:	7f ff bb 97 	call  20099a8 <rtems_semaphore_release>        <== NOT EXECUTED
 201ab50:	d0 05 a0 9c 	ld  [ %l6 + 0x9c ], %o0                        <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
 201ab54:	40 00 02 96 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201ab58:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
 201ab5c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201ab60:	10 80 01 07 	b  201af7c <msdos_dir_read+0x4f4>              <== NOT EXECUTED
 201ab64:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
        }                                                             
                                                                      
        for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)  
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
 201ab68:	ae 00 c0 1c 	add  %g3, %i4, %l7                             <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
 201ab6c:	c6 08 c0 1c 	ldub  [ %g3 + %i4 ], %g3                       <== NOT EXECUTED
 201ab70:	88 88 e0 ff 	andcc  %g3, 0xff, %g4                          <== NOT EXECUTED
 201ab74:	12 80 00 04 	bne  201ab84 <msdos_dir_read+0xfc>             <== NOT EXECUTED
 201ab78:	80 a1 20 e5 	cmp  %g4, 0xe5                                 <== NOT EXECUTED
                break;                                                
        }                                                             
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201ab7c:	10 80 00 ef 	b  201af38 <msdos_dir_read+0x4b0>              <== NOT EXECUTED
 201ab80:	d0 05 a0 9c 	ld  [ %l6 + 0x9c ], %o0                        <== 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)
 201ab84:	22 80 00 df 	be,a   201af00 <msdos_dir_read+0x478>          <== NOT EXECUTED
 201ab88:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
                continue;                                             
                                                                      
            /* Is the directory entry empty a volume label */         
            if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&  
 201ab8c:	c8 0d e0 0b 	ldub  [ %l7 + 0xb ], %g4                       <== NOT EXECUTED
 201ab90:	9e 09 20 08 	and  %g4, 8, %o7                               <== NOT EXECUTED
 201ab94:	80 8b e0 ff 	btst  0xff, %o7                                <== NOT EXECUTED
 201ab98:	22 80 00 07 	be,a   201abb4 <msdos_dir_read+0x12c>          <== NOT EXECUTED
 201ab9c:	88 09 20 3f 	and  %g4, 0x3f, %g4                            <== NOT EXECUTED
 201aba0:	9e 09 20 3f 	and  %g4, 0x3f, %o7                            <== NOT EXECUTED
 201aba4:	80 a3 e0 0f 	cmp  %o7, 0xf                                  <== NOT EXECUTED
 201aba8:	32 80 00 d6 	bne,a   201af00 <msdos_dir_read+0x478>         <== NOT EXECUTED
 201abac:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== 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) ==     
 201abb0:	88 09 20 3f 	and  %g4, 0x3f, %g4                            <== NOT EXECUTED
 201abb4:	80 a1 20 0f 	cmp  %g4, 0xf                                  <== NOT EXECUTED
 201abb8:	12 80 00 3e 	bne  201acb0 <msdos_dir_read+0x228>            <== NOT EXECUTED
 201abbc:	80 a4 e0 00 	cmp  %l3, 0                                    <== NOT EXECUTED
                int   q;                                              
                                                                      
                /*                                                    
                 * Is this is the first entry of a LFN ?              
                 */                                                   
                if (lfn_start == FAT_FILE_SHORT_NAME)                 
 201abc0:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
 201abc4:	32 80 00 0f 	bne,a   201ac00 <msdos_dir_read+0x178>         <== NOT EXECUTED
 201abc8:	c6 0d c0 00 	ldub  [ %l7 ], %g3                             <== NOT EXECUTED
                {                                                     
                    /*                                                
                     * The first entry must have the last long entry flag set.
                     */                                               
                    if ((*MSDOS_DIR_ENTRY_TYPE(entry) &               
 201abcc:	88 08 e0 40 	and  %g3, 0x40, %g4                            <== NOT EXECUTED
 201abd0:	80 89 20 ff 	btst  0xff, %g4                                <== NOT EXECUTED
 201abd4:	22 80 00 cb 	be,a   201af00 <msdos_dir_read+0x478>          <== NOT EXECUTED
 201abd8:	b8 07 20 20 	add  %i4, 0x20, %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)        
 201abdc:	b6 07 00 11 	add  %i4, %l1, %i3                             <== 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) &     
 201abe0:	ba 08 e0 3f 	and  %g3, 0x3f, %i5                            <== NOT EXECUTED
                        continue;                                     
                                                                      
                    /*                                                
                     * Remember the start location of the long file name.
                     */                                               
                    lfn_start =                                       
 201abe4:	b7 36 e0 05 	srl  %i3, 5, %i3                               <== 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);    
 201abe8:	e8 0d e0 0d 	ldub  [ %l7 + 0xd ], %l4                       <== NOT EXECUTED
                    memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
 201abec:	90 07 be fc 	add  %fp, -260, %o0                            <== NOT EXECUTED
 201abf0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201abf4:	40 00 05 6a 	call  201c19c <memset>                         <== NOT EXECUTED
 201abf8:	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) &   
 201abfc:	c6 0d c0 00 	ldub  [ %l7 ], %g3                             <== NOT EXECUTED
 201ac00:	86 08 e0 3f 	and  %g3, 0x3f, %g3                            <== NOT EXECUTED
 201ac04:	80 a7 40 03 	cmp  %i5, %g3                                  <== NOT EXECUTED
 201ac08:	32 80 00 bb 	bne,a   201aef4 <msdos_dir_read+0x46c>         <== NOT EXECUTED
 201ac0c:	b6 10 3f ff 	mov  -1, %i3                                   <== NOT EXECUTED
                                     MSDOS_LAST_LONG_ENTRY_MASK)) ||  
 201ac10:	c6 0d e0 0d 	ldub  [ %l7 + 0xd ], %g3                       <== NOT EXECUTED
 201ac14:	88 0d 20 ff 	and  %l4, 0xff, %g4                            <== NOT EXECUTED
 201ac18:	80 a1 00 03 	cmp  %g4, %g3                                  <== NOT EXECUTED
 201ac1c:	32 80 00 b6 	bne,a   201aef4 <msdos_dir_read+0x46c>         <== NOT EXECUTED
 201ac20:	b6 10 3f ff 	mov  -1, %i3                                   <== 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--;                                        
 201ac24:	ba 07 7f ff 	add  %i5, -1, %i5                              <== NOT EXECUTED
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
 201ac28:	87 2f 60 02 	sll  %i5, 2, %g3                               <== NOT EXECUTED
 201ac2c:	89 2f 60 04 	sll  %i5, 4, %g4                               <== 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)        
 201ac30:	82 07 be e8 	add  %fp, -280, %g1                            <== NOT EXECUTED
                 * fit in the directory entry name field.             
                 */                                                   
                                                                      
                lfn_entries--;                                        
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
 201ac34:	88 21 00 03 	sub  %g4, %g3, %g4                             <== 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;                                        
 201ac38:	84 05 e0 01 	add  %l7, 1, %g2                               <== NOT EXECUTED
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
 201ac3c:	88 01 00 1d 	add  %g4, %i5, %g4                             <== NOT EXECUTED
                                                                      
                for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)         
 201ac40:	86 10 20 00 	clr  %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)        
 201ac44:	9e 00 40 04 	add  %g1, %g4, %o7                             <== 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))         
 201ac48:	9a 00 c0 04 	add  %g3, %g4, %o5                             <== NOT EXECUTED
 201ac4c:	80 a3 60 fe 	cmp  %o5, 0xfe                                 <== NOT EXECUTED
 201ac50:	18 80 00 a3 	bgu  201aedc <msdos_dir_read+0x454>            <== NOT EXECUTED
 201ac54:	9a 03 c0 03 	add  %o7, %g3, %o5                             <== NOT EXECUTED
                        break;                                        
                                                                      
                    tmp_dirent.d_name[o++] = *p;                      
 201ac58:	d8 08 80 00 	ldub  [ %g2 ], %o4                             <== NOT EXECUTED
 201ac5c:	d8 2b 60 14 	stb  %o4, [ %o5 + 0x14 ]                       <== NOT EXECUTED
                                                                      
                    if (*p == '\0')                                   
 201ac60:	da 48 80 00 	ldsb  [ %g2 ], %o5                             <== NOT EXECUTED
 201ac64:	80 a3 60 00 	cmp  %o5, 0                                    <== NOT EXECUTED
 201ac68:	02 80 00 9d 	be  201aedc <msdos_dir_read+0x454>             <== NOT EXECUTED
 201ac6c:	80 a0 e0 04 	cmp  %g3, 4                                    <== NOT EXECUTED
                        break;                                        
                                                                      
                    switch (q)                                        
 201ac70:	02 80 00 06 	be  201ac88 <msdos_dir_read+0x200>             <== NOT EXECUTED
 201ac74:	80 a0 e0 0a 	cmp  %g3, 0xa                                  <== NOT EXECUTED
 201ac78:	32 80 00 08 	bne,a   201ac98 <msdos_dir_read+0x210>         <== NOT EXECUTED
 201ac7c:	84 00 a0 02 	add  %g2, 2, %g2                               <== NOT EXECUTED
                    {                                                 
                        case 4:                                       
                            p += 5;                                   
                            break;                                    
                        case 10:                                      
                            p += 4;                                   
 201ac80:	10 80 00 04 	b  201ac90 <msdos_dir_read+0x208>              <== NOT EXECUTED
 201ac84:	84 00 a0 04 	add  %g2, 4, %g2                               <== NOT EXECUTED
                                                                      
                    switch (q)                                        
                    {                                                 
                        case 4:                                       
                            p += 5;                                   
                            break;                                    
 201ac88:	10 80 00 04 	b  201ac98 <msdos_dir_read+0x210>              <== NOT EXECUTED
 201ac8c:	84 00 a0 05 	add  %g2, 5, %g2                               <== NOT EXECUTED
                        case 10:                                      
                            p += 4;                                   
                            break;                                    
 201ac90:	10 80 00 03 	b  201ac9c <msdos_dir_read+0x214>              <== NOT EXECUTED
 201ac94:	86 00 e0 01 	inc  %g3                                       <== 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++)         
 201ac98:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
 201ac9c:	80 a0 e0 0d 	cmp  %g3, 0xd                                  <== NOT EXECUTED
 201aca0:	12 bf ff eb 	bne  201ac4c <msdos_dir_read+0x1c4>            <== NOT EXECUTED
 201aca4:	9a 00 c0 04 	add  %g3, %g4, %o5                             <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
 201aca8:	10 80 00 8e 	b  201aee0 <msdos_dir_read+0x458>              <== NOT EXECUTED
 201acac:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
                fat_dir_pos_t dir_pos;                                
                                                                      
                /*                                                    
                 * Skip active entries until get the entry to start from.
                 */                                                   
                if (start)                                            
 201acb0:	02 80 00 04 	be  201acc0 <msdos_dir_read+0x238>             <== NOT EXECUTED
 201acb4:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
                {                                                     
                    lfn_start = FAT_FILE_SHORT_NAME;                  
                    start--;                                          
 201acb8:	10 80 00 8e 	b  201aef0 <msdos_dir_read+0x468>              <== NOT EXECUTED
 201acbc:	a6 04 ff ff 	add  %l3, -1, %l3                              <== 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, 
 201acc0:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 201acc4:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 201acc8:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
 201accc:	7f ff de 72 	call  2012694 <fat_file_ioctl>                 <== NOT EXECUTED
 201acd0:	98 07 be d4 	add  %fp, -300, %o4                            <== NOT EXECUTED
                                    j * bts2rd, &cur_cln);            
                if (rc != RC_OK)                                      
 201acd4:	b2 92 20 00 	orcc  %o0, 0, %i1                              <== NOT EXECUTED
 201acd8:	12 80 00 7d 	bne  201aecc <msdos_dir_read+0x444>            <== NOT EXECUTED
 201acdc:	c6 07 be d4 	ld  [ %fp + -300 ], %g3                        <== 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;                           
 201ace0:	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;                          
 201ace4:	c6 27 be d8 	st  %g3, [ %fp + -296 ]                        <== NOT EXECUTED
 201ace8:	c2 27 be e0 	st  %g1, [ %fp + -288 ]                        <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
 201acec:	c2 27 be e4 	st  %g1, [ %fp + -284 ]                        <== NOT EXECUTED
                dir_pos.sname.ofs = i;                                
 201acf0:	f8 27 be dc 	st  %i4, [ %fp + -292 ]                        <== NOT EXECUTED
                rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
 201acf4:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
 201acf8:	92 07 be d8 	add  %fp, -296, %o1                            <== NOT EXECUTED
 201acfc:	7f ff dd 23 	call  2012188 <fat_file_open>                  <== NOT EXECUTED
 201ad00:	94 07 be d0 	add  %fp, -304, %o2                            <== NOT EXECUTED
                if (rc != RC_OK)                                      
 201ad04:	b2 92 20 00 	orcc  %o0, 0, %i1                              <== NOT EXECUTED
 201ad08:	12 80 00 71 	bne  201aecc <msdos_dir_read+0x444>            <== NOT EXECUTED
 201ad0c:	c6 07 be d0 	ld  [ %fp + -304 ], %g3                        <== 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);          
 201ad10:	82 10 21 18 	mov  0x118, %g1                                <== NOT EXECUTED
                tmp_dirent.d_ino = tmp_fat_fd->ino;                   
 201ad14:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         <== 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;                    
 201ad18:	c0 27 be f0 	clr  [ %fp + -272 ]                            <== NOT EXECUTED
 201ad1c:	f4 27 be f4 	st  %i2, [ %fp + -268 ]                        <== NOT EXECUTED
                tmp_dirent.d_reclen = sizeof(struct dirent);          
 201ad20:	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)                 
 201ad24:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
 201ad28:	02 80 00 1d 	be  201ad9c <msdos_dir_read+0x314>             <== NOT EXECUTED
 201ad2c:	c6 27 be e8 	st  %g3, [ %fp + -280 ]                        <== NOT EXECUTED
 201ad30:	88 10 20 00 	clr  %g4                                       <== NOT EXECUTED
 201ad34:	86 10 20 00 	clr  %g3                                       <== 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;  
 201ad38:	da 0d c0 04 	ldub  [ %l7 + %g4 ], %o5                       <== NOT EXECUTED
 201ad3c:	9e 08 e0 01 	and  %g3, 1, %o7                               <== NOT EXECUTED
 201ad40:	80 a0 00 0f 	cmp  %g0, %o7                                  <== NOT EXECUTED
 201ad44:	86 08 e0 ff 	and  %g3, 0xff, %g3                            <== NOT EXECUTED
 201ad48:	9e 40 3f ff 	addx  %g0, -1, %o7                             <== NOT EXECUTED
 201ad4c:	87 30 e0 01 	srl  %g3, 1, %g3                               <== NOT EXECUTED
 201ad50:	9e 0b e0 80 	and  %o7, 0x80, %o7                            <== NOT EXECUTED
 201ad54:	86 03 40 03 	add  %o5, %g3, %g3                             <== NOT EXECUTED
 201ad58:	9e 03 ff 80 	add  %o7, -128, %o7                            <== NOT EXECUTED
                {                                                     
                    uint8_t  cs = 0;                                  
                    uint8_t* p = (uint8_t*) entry;                    
                    int      i;                                       
                                                                      
                    for (i = 0; i < 11; i++, p++)                     
 201ad5c:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
 201ad60:	80 a1 20 0b 	cmp  %g4, 0xb                                  <== NOT EXECUTED
 201ad64:	12 bf ff f5 	bne  201ad38 <msdos_dir_read+0x2b0>            <== NOT EXECUTED
 201ad68:	86 00 c0 0f 	add  %g3, %o7, %g3                             <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
                                                                      
                    if (lfn_entries || (lfn_checksum != cs))          
 201ad6c:	86 18 c0 14 	xor  %g3, %l4, %g3                             <== NOT EXECUTED
 201ad70:	80 88 e0 ff 	btst  0xff, %g3                                <== NOT EXECUTED
 201ad74:	12 80 00 0b 	bne  201ada0 <msdos_dir_read+0x318>            <== NOT EXECUTED
 201ad78:	86 10 20 08 	mov  8, %g3                                    <== NOT EXECUTED
 201ad7c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
 201ad80:	12 80 00 09 	bne  201ada4 <msdos_dir_read+0x31c>            <== NOT EXECUTED
 201ad84:	88 05 c0 03 	add  %l7, %g3, %g4                             <== NOT EXECUTED
 201ad88:	30 80 00 70 	b,a   201af48 <msdos_dir_read+0x4c0>           <== NOT EXECUTED
  const char *src_tmp;                                                
                                                                      
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
 201ad8c:	32 80 00 06 	bne,a   201ada4 <msdos_dir_read+0x31c>         <== NOT EXECUTED
 201ad90:	88 05 c0 03 	add  %l7, %g3, %g4                             <== NOT EXECUTED
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
 201ad94:	10 80 00 09 	b  201adb8 <msdos_dir_read+0x330>              <== NOT EXECUTED
 201ad98:	03 00 80 b4 	sethi  %hi(0x202d000), %g1                     <== NOT EXECUTED
  const char *src_tmp;                                                
                                                                      
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
 201ad9c:	86 10 20 08 	mov  8, %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)        
 201ada0:	88 05 c0 03 	add  %l7, %g3, %g4                             <== 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) &&                                                    
 201ada4:	c8 49 3f ff 	ldsb  [ %g4 + -1 ], %g4                        <== NOT EXECUTED
 201ada8:	80 a1 20 20 	cmp  %g4, 0x20                                 <== NOT EXECUTED
 201adac:	22 bf ff f8 	be,a   201ad8c <msdos_dir_read+0x304>          <== NOT EXECUTED
 201adb0:	86 80 ff ff 	addcc  %g3, -1, %g3                            <== NOT EXECUTED
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
 201adb4:	03 00 80 b4 	sethi  %hi(0x202d000), %g1                     <== NOT EXECUTED
 201adb8:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
 201adbc:	da 00 60 08 	ld  [ %g1 + 8 ], %o5                           <== 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(
 201adc0:	10 80 00 0b 	b  201adec <msdos_dir_read+0x364>              <== NOT EXECUTED
 201adc4:	88 07 be fc 	add  %fp, -260, %g4                            <== NOT EXECUTED
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
 201adc8:	98 03 40 0f 	add  %o5, %o7, %o4                             <== NOT EXECUTED
 201adcc:	d8 0b 20 01 	ldub  [ %o4 + 1 ], %o4                         <== NOT EXECUTED
 201add0:	98 0b 20 03 	and  %o4, 3, %o4                               <== NOT EXECUTED
 201add4:	80 a3 20 01 	cmp  %o4, 1                                    <== NOT EXECUTED
 201add8:	22 80 00 02 	be,a   201ade0 <msdos_dir_read+0x358>          <== NOT EXECUTED
 201addc:	9e 03 e0 20 	add  %o7, 0x20, %o7                            <== NOT EXECUTED
 201ade0:	de 29 00 00 	stb  %o7, [ %g4 ]                              <== NOT EXECUTED
 201ade4:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
 201ade8:	88 01 20 01 	inc  %g4                                       <== 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)        
 201adec:	9e 20 c0 1b 	sub  %g3, %i3, %o7                             <== NOT EXECUTED
  /*                                                                  
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
 201adf0:	80 a3 e0 00 	cmp  %o7, 0                                    <== NOT EXECUTED
 201adf4:	34 bf ff f5 	bg,a   201adc8 <msdos_dir_read+0x340>          <== NOT EXECUTED
 201adf8:	de 0d c0 1b 	ldub  [ %l7 + %i3 ], %o7                       <== 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) &&                                                    
 201adfc:	f6 4d e0 0a 	ldsb  [ %l7 + 0xa ], %i3                       <== NOT EXECUTED
 201ae00:	80 a6 e0 20 	cmp  %i3, 0x20                                 <== NOT EXECUTED
 201ae04:	12 80 00 55 	bne  201af58 <msdos_dir_read+0x4d0>            <== NOT EXECUTED
 201ae08:	b6 10 20 03 	mov  3, %i3                                    <== NOT EXECUTED
 201ae0c:	f6 4d e0 09 	ldsb  [ %l7 + 9 ], %i3                         <== NOT EXECUTED
 201ae10:	80 a6 e0 20 	cmp  %i3, 0x20                                 <== NOT EXECUTED
 201ae14:	12 80 00 51 	bne  201af58 <msdos_dir_read+0x4d0>            <== NOT EXECUTED
 201ae18:	b6 10 20 02 	mov  2, %i3                                    <== NOT EXECUTED
 201ae1c:	f6 4d e0 08 	ldsb  [ %l7 + 8 ], %i3                         <== NOT EXECUTED
 201ae20:	80 a6 e0 20 	cmp  %i3, 0x20                                 <== NOT EXECUTED
 201ae24:	22 80 00 18 	be,a   201ae84 <msdos_dir_read+0x3fc>          <== NOT EXECUTED
 201ae28:	c0 29 00 00 	clrb  [ %g4 ]                                  <== NOT EXECUTED
 201ae2c:	10 80 00 4b 	b  201af58 <msdos_dir_read+0x4d0>              <== NOT EXECUTED
 201ae30:	b6 10 20 01 	mov  1, %i3                                    <== NOT EXECUTED
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
 201ae34:	da 0b 60 08 	ldub  [ %o5 + 8 ], %o5                         <== NOT EXECUTED
 201ae38:	94 03 00 0d 	add  %o4, %o5, %o2                             <== NOT EXECUTED
 201ae3c:	d4 0a a0 01 	ldub  [ %o2 + 1 ], %o2                         <== NOT EXECUTED
 201ae40:	94 0a a0 03 	and  %o2, 3, %o2                               <== NOT EXECUTED
 201ae44:	80 a2 a0 01 	cmp  %o2, 1                                    <== NOT EXECUTED
 201ae48:	22 80 00 02 	be,a   201ae50 <msdos_dir_read+0x3c8>          <== NOT EXECUTED
 201ae4c:	9a 03 60 20 	add  %o5, 0x20, %o5                            <== 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)        
 201ae50:	94 01 00 0f 	add  %g4, %o7, %o2                             <== NOT EXECUTED
 201ae54:	9e 03 e0 01 	inc  %o7                                       <== NOT EXECUTED
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
 201ae58:	da 2a a0 01 	stb  %o5, [ %o2 + 1 ]                          <== NOT EXECUTED
 * RETURNS:                                                           
 *     the number of bytes read on success, or -1 if error occured (errno
 *     set apropriately).                                             
 */                                                                   
ssize_t                                                               
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)        
 201ae5c:	9a 26 c0 0f 	sub  %i3, %o7, %o5                             <== NOT EXECUTED
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
 201ae60:	80 a3 60 00 	cmp  %o5, 0                                    <== NOT EXECUTED
 201ae64:	14 bf ff f4 	bg  201ae34 <msdos_dir_read+0x3ac>             <== NOT EXECUTED
 201ae68:	9a 05 c0 0f 	add  %l7, %o7, %o5                             <== 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)        
 201ae6c:	84 38 00 1b 	xnor  %g0, %i3, %g2                            <== NOT EXECUTED
 201ae70:	85 38 a0 1f 	sra  %g2, 0x1f, %g2                            <== NOT EXECUTED
 201ae74:	b6 0e c0 02 	and  %i3, %g2, %i3                             <== NOT EXECUTED
 201ae78:	88 02 c0 1b 	add  %o3, %i3, %g4                             <== NOT EXECUTED
 201ae7c:	86 00 c0 1b 	add  %g3, %i3, %g3                             <== NOT EXECUTED
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
      len++;                                                          
    }                                                                 
  }                                                                   
  *dst = '\0'; /* terminate string */                                 
 201ae80:	c0 29 00 00 	clrb  [ %g4 ]                                  <== 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(
 201ae84:	c6 37 be fa 	sth  %g3, [ %fp + -262 ]                       <== NOT EXECUTED
 201ae88:	b6 10 3f ff 	mov  -1, %i3                                   <== NOT EXECUTED
                else                                                  
                {                                                     
                    tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);  
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
 201ae8c:	c2 07 a0 48 	ld  [ %fp + 0x48 ], %g1                        <== NOT EXECUTED
 201ae90:	92 07 be e8 	add  %fp, -280, %o1                            <== NOT EXECUTED
 201ae94:	90 00 40 1a 	add  %g1, %i2, %o0                             <== NOT EXECUTED
 201ae98:	40 00 04 84 	call  201c0a8 <memcpy>                         <== NOT EXECUTED
 201ae9c:	94 10 21 18 	mov  0x118, %o2                                <== NOT EXECUTED
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
 201aea0:	c4 1e 20 08 	ldd  [ %i0 + 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);       
 201aea4:	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);    
 201aea8:	9a 80 e1 18 	addcc  %g3, 0x118, %o5                         <== NOT EXECUTED
 201aeac:	98 40 a0 00 	addx  %g2, 0, %o4                              <== 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);       
 201aeb0:	90 10 00 16 	mov  %l6, %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);    
 201aeb4:	d8 3e 20 08 	std  %o4, [ %i0 + 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);       
 201aeb8:	7f ff dd ca 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 201aebc:	b4 06 a1 18 	add  %i2, 0x118, %i2                           <== NOT EXECUTED
                if (rc != RC_OK)                                      
 201aec0:	b2 92 20 00 	orcc  %o0, 0, %i1                              <== NOT EXECUTED
 201aec4:	02 80 00 06 	be  201aedc <msdos_dir_read+0x454>             <== NOT EXECUTED
 201aec8:	a4 04 be e8 	add  %l2, -280, %l2                            <== NOT EXECUTED
                {                                                     
                    rtems_semaphore_release(fs_info->vol_sema);       
 201aecc:	7f ff ba b7 	call  20099a8 <rtems_semaphore_release>        <== NOT EXECUTED
 201aed0:	d0 05 a0 9c 	ld  [ %l6 + 0x9c ], %o0                        <== NOT EXECUTED
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return cmpltd;                                                    
}                                                                     
 201aed4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201aed8:	91 e8 00 19 	restore  %g0, %i1, %o0                         <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
 201aedc:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
 201aee0:	32 80 00 08 	bne,a   201af00 <msdos_dir_read+0x478>         <== NOT EXECUTED
 201aee4:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
 201aee8:	10 80 00 10 	b  201af28 <msdos_dir_read+0x4a0>              <== NOT EXECUTED
 201aeec:	a2 04 40 15 	add  %l1, %l5, %l1                             <== NOT EXECUTED
                 */                                                   
                if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &   
                                     MSDOS_LAST_LONG_ENTRY_MASK)) ||  
                    (lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry))) 
                {                                                     
                    lfn_start = FAT_FILE_SHORT_NAME;                  
 201aef0:	b6 10 3f ff 	mov  -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)  
 201aef4:	10 80 00 03 	b  201af00 <msdos_dir_read+0x478>              <== NOT EXECUTED
 201aef8:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
         * 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),      
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
 201aefc:	b8 10 20 00 	clr  %i4                                       <== 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)  
 201af00:	c2 07 be cc 	ld  [ %fp + -308 ], %g1                        <== NOT EXECUTED
 201af04:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
 201af08:	2a bf ff 18 	bcs,a   201ab68 <msdos_dir_read+0xe0>          <== NOT EXECUTED
 201af0c:	c6 05 a0 a0 	ld  [ %l6 + 0xa0 ], %g3                        <== NOT EXECUTED
 201af10:	10 80 00 06 	b  201af28 <msdos_dir_read+0x4a0>              <== NOT EXECUTED
 201af14:	a2 04 40 15 	add  %l1, %l5, %l1                             <== NOT EXECUTED
             fat_fd->fat_file_size                              :     
             fs_info->fat.vol.bpc;                                    
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201af18:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
 201af1c:	a8 10 20 00 	clr  %l4                                       <== NOT EXECUTED
 201af20:	b6 10 3f ff 	mov  -1, %i3                                   <== NOT EXECUTED
 201af24:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    while (count > 0)                                                 
 201af28:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
 201af2c:	32 bf ff 00 	bne,a   201ab2c <msdos_dir_read+0xa4>          <== NOT EXECUTED
 201af30:	d8 05 a0 a0 	ld  [ %l6 + 0xa0 ], %o4                        <== NOT EXECUTED
                break;                                                
        }                                                             
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201af34:	d0 05 a0 9c 	ld  [ %l6 + 0x9c ], %o0                        <== NOT EXECUTED
 201af38:	7f ff ba 9c 	call  20099a8 <rtems_semaphore_release>        <== NOT EXECUTED
 201af3c:	b2 10 00 1a 	mov  %i2, %i1                                  <== NOT EXECUTED
    return cmpltd;                                                    
}                                                                     
 201af40:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201af44:	91 e8 00 19 	restore  %g0, %i1, %o0                         <== 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);  
 201af48:	40 00 0a a3 	call  201d9d4 <strlen>                         <== NOT EXECUTED
 201af4c:	90 07 be fc 	add  %fp, -260, %o0                            <== NOT EXECUTED
 201af50:	10 bf ff cf 	b  201ae8c <msdos_dir_read+0x404>              <== NOT EXECUTED
 201af54:	d0 37 be fa 	sth  %o0, [ %fp + -262 ]                       <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
 201af58:	82 10 20 2e 	mov  0x2e, %g1                                 <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
 201af5c:	9e 06 e0 01 	add  %i3, 1, %o7                               <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
 201af60:	c2 29 00 00 	stb  %g1, [ %g4 ]                              <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
 201af64:	86 00 c0 0f 	add  %g3, %o7, %g3                             <== NOT EXECUTED
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
 201af68:	03 00 80 b4 	sethi  %hi(0x202d000), %g1                     <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
 201af6c:	96 01 20 01 	add  %g4, 1, %o3                               <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
 201af70:	d8 00 60 08 	ld  [ %g1 + 8 ], %o4                           <== NOT EXECUTED
 201af74:	10 bf ff ba 	b  201ae5c <msdos_dir_read+0x3d4>              <== NOT EXECUTED
 201af78:	9e 10 20 00 	clr  %o7                                       <== NOT EXECUTED
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return cmpltd;                                                    
}                                                                     
 201af7c:	b0 10 00 19 	mov  %i1, %i0                                  <== NOT EXECUTED
 201af80:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201af84:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201af88 <msdos_dir_stat>: int msdos_dir_stat( const rtems_filesystem_location_info_t *loc, struct stat *buf ) {
 201af88:	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;              
 201af8c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
 201af90:	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;              
 201af94:	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,        
 201af98:	92 10 20 00 	clr  %o1                                       
 201af9c:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
 201afa0:	7f ff ba 39 	call  2009884 <rtems_semaphore_obtain>         
 201afa4:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201afa8:	80 a2 20 00 	cmp  %o0, 0                                    
 201afac:	22 80 00 08 	be,a   201afcc <msdos_dir_stat+0x44>           <== ALWAYS TAKEN
 201afb0:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
        rtems_set_errno_and_return_minus_one(EIO);                    
 201afb4:	40 00 01 7e 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201afb8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201afbc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201afc0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 201afc4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201afc8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    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;                           
    buf->st_mtime = fat_fd->mtime;                                    
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201afcc:	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);
 201afd0:	c4 18 40 00 	ldd  [ %g1 ], %g2                              
    buf->st_ino = fat_fd->ino;                                        
 201afd4:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
    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);
 201afd8:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    buf->st_ino = fat_fd->ino;                                        
 201afdc:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
 201afe0:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 201afe4:	82 10 61 ff 	or  %g1, 0x1ff, %g1	! 41ff <PROM_START+0x41ff> 
 201afe8:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
 201afec:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %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;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
 201aff0:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
    buf->st_size = fat_fd->fat_file_size;                             
 201aff4:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
 201aff8:	83 30 60 09 	srl  %g1, 9, %g1                               
 201affc:	c2 26 60 44 	st  %g1, [ %i1 + 0x44 ]                        
    buf->st_blksize = fs_info->fat.vol.bps;                           
 201b000:	c2 17 40 00 	lduh  [ %i5 ], %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;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
 201b004:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    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;                           
 201b008:	c2 26 60 40 	st  %g1, [ %i1 + 0x40 ]                        
    buf->st_mtime = fat_fd->mtime;                                    
 201b00c:	c2 07 20 40 	ld  [ %i4 + 0x40 ], %g1                        
                                                                      
    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;            
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
 201b010:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
    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;                                    
 201b014:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b018:	7f ff ba 64 	call  20099a8 <rtems_semaphore_release>        
 201b01c:	b0 10 20 00 	clr  %i0                                       
    return RC_OK;                                                     
}                                                                     
 201b020:	81 c7 e0 08 	ret                                            
 201b024:	81 e8 00 00 	restore                                        
                                                                      

02017ae0 <msdos_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
 2017ae0:	9d e3 bf a0 	save  %sp, -96, %sp                            
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
 2017ae4:	82 10 20 00 	clr  %g1                                       
 2017ae8:	80 a6 e0 01 	cmp  %i3, 1                                    
 2017aec:	12 80 00 06 	bne  2017b04 <msdos_eval_token+0x24>           
 2017af0:	ba 10 00 18 	mov  %i0, %i5                                  
 2017af4:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
 2017af8:	82 18 60 2e 	xor  %g1, 0x2e, %g1                            
 2017afc:	80 a0 00 01 	cmp  %g0, %g1                                  
 2017b00:	82 60 3f ff 	subx  %g0, -1, %g1                             
  rtems_filesystem_eval_path_generic_status status =                  
    RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;                          
                                                                      
  if (rtems_filesystem_is_current_directory(token, tokenlen)) {       
 2017b04:	80 a0 60 00 	cmp  %g1, 0                                    
 2017b08:	02 80 00 05 	be  2017b1c <msdos_eval_token+0x3c>            
 2017b0c:	b0 10 20 00 	clr  %i0                                       
                                                                      
static inline void rtems_filesystem_eval_path_clear_token(            
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  ctx->tokenlen = 0;                                                  
 2017b10:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
 2017b14:	81 c7 e0 08 	ret                                            
 2017b18:	81 e8 00 00 	restore                                        
    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);            
 2017b1c:	90 07 60 18 	add  %i5, 0x18, %o0                            
 2017b20:	92 10 00 1a 	mov  %i2, %o1                                  
 2017b24:	40 00 05 aa 	call  20191cc <msdos_find_name>                
 2017b28:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    if (rc == RC_OK) {                                                
 2017b2c:	80 a2 20 00 	cmp  %o0, 0                                    
 2017b30:	12 80 00 12 	bne  2017b78 <msdos_eval_token+0x98>           
 2017b34:	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)                       
 2017b38:	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;                
 2017b3c:	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)                       
 2017b40:	c4 00 a0 10 	ld  [ %g2 + 0x10 ], %g2                        
 2017b44:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
 2017b48:	80 a0 a0 00 	cmp  %g2, 0                                    
 2017b4c:	12 80 00 04 	bne  2017b5c <msdos_eval_token+0x7c>           
 2017b50:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
        loc->handlers = fs_info->directory_handlers;                  
 2017b54:	10 80 00 03 	b  2017b60 <msdos_eval_token+0x80>             
 2017b58:	c2 00 60 94 	ld  [ %g1 + 0x94 ], %g1                        
    else                                                              
        loc->handlers = fs_info->file_handlers;                       
 2017b5c:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
 2017b60:	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)) {                 
 2017b64:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 2017b68:	80 a0 00 01 	cmp  %g0, %g1                                  
 2017b6c:	b0 60 3f ff 	subx  %g0, -1, %i0                             
 2017b70:	81 c7 e0 08 	ret                                            
 2017b74:	81 e8 00 00 	restore                                        
      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) {                      
 2017b78:	82 10 61 01 	or  %g1, 0x101, %g1                            
 2017b7c:	80 a2 00 01 	cmp  %o0, %g1                                  
 2017b80:	02 bf ff e5 	be  2017b14 <msdos_eval_token+0x34>            <== ALWAYS TAKEN
 2017b84:	b0 10 20 02 	mov  2, %i0                                    
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, 0);                       
 2017b88:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2017b8c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2017b90:	7f ff ba 79 	call  2006574 <rtems_filesystem_eval_path_error><== NOT EXECUTED
 2017b94:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
 2017b98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2017b9c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201b084 <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) {
 201b084:	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;     
 201b088:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 201b08c:	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;     
 201b090:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 201b094:	94 10 20 00 	clr  %o2                                       
 201b098:	7f ff b9 fb 	call  2009884 <rtems_semaphore_obtain>         
 201b09c:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201b0a0:	80 a2 20 00 	cmp  %o0, 0                                    
 201b0a4:	02 80 00 08 	be  201b0c4 <msdos_file_close+0x40>            <== ALWAYS TAKEN
 201b0a8:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
 201b0ac:	40 00 01 40 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b0b0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 201b0b4:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201b0b8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 201b0bc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b0c0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    rc = msdos_file_update(iop);                                      
 201b0c4:	7f ff ff d9 	call  201b028 <msdos_file_update>              
 201b0c8:	90 10 00 18 	mov  %i0, %o0                                  
 201b0cc:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b0d0:	7f ff ba 36 	call  20099a8 <rtems_semaphore_release>        
 201b0d4:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return rc;                                                        
}                                                                     
 201b0d8:	81 c7 e0 08 	ret                                            
 201b0dc:	81 e8 00 00 	restore                                        
                                                                      

0201b2e8 <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) {
 201b2e8:	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;     
 201b2ec:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
 201b2f0:	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;     
 201b2f4:	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,        
 201b2f8:	92 10 20 00 	clr  %o1                                       
 201b2fc:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
 201b300:	7f ff b9 61 	call  2009884 <rtems_semaphore_obtain>         
 201b304:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201b308:	80 a2 20 00 	cmp  %o0, 0                                    
 201b30c:	02 80 00 08 	be  201b32c <msdos_file_ftruncate+0x44>        <== ALWAYS TAKEN
 201b310:	80 a2 00 19 	cmp  %o0, %i1                                  
        rtems_set_errno_and_return_minus_one(EIO);                    
 201b314:	40 00 00 a6 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b318:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201b31c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201b320:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 201b324:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b328:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    old_length = fat_fd->fat_file_size;                               
    if (length < old_length) {                                        
 201b32c:	14 80 00 08 	bg  201b34c <msdos_file_ftruncate+0x64>        <== NEVER TAKEN
 201b330:	f6 07 20 18 	ld  [ %i4 + 0x18 ], %i3                        
 201b334:	80 a2 00 19 	cmp  %o0, %i1                                  
 201b338:	12 80 00 0d 	bne  201b36c <msdos_file_ftruncate+0x84>       <== NEVER TAKEN
 201b33c:	90 10 00 1d 	mov  %i5, %o0                                  
 201b340:	80 a6 c0 1a 	cmp  %i3, %i2                                  
 201b344:	08 80 00 0b 	bleu  201b370 <msdos_file_ftruncate+0x88>      
 201b348:	92 10 00 1c 	mov  %i4, %o1                                  
        rc = fat_file_truncate(&fs_info->fat, fat_fd, length);        
 201b34c:	90 10 00 1d 	mov  %i5, %o0                                  
 201b350:	92 10 00 1c 	mov  %i4, %o1                                  
 201b354:	7f ff dc 5e 	call  20124cc <fat_file_truncate>              
 201b358:	94 10 00 1a 	mov  %i2, %o2                                  
            errno = ENOSPC;                                           
            rc = -1;                                                  
        }                                                             
    }                                                                 
                                                                      
    if (rc == RC_OK) {                                                
 201b35c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201b360:	22 80 00 18 	be,a   201b3c0 <msdos_file_ftruncate+0xd8>     <== ALWAYS TAKEN
 201b364:	f4 27 20 18 	st  %i2, [ %i4 + 0x18 ]                        
 201b368:	30 80 00 16 	b,a   201b3c0 <msdos_file_ftruncate+0xd8>      <== NOT EXECUTED
    if (length < old_length) {                                        
        rc = fat_file_truncate(&fs_info->fat, fat_fd, length);        
    } else {                                                          
        uint32_t new_length;                                          
                                                                      
        rc = fat_file_extend(&fs_info->fat,                           
 201b36c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201b370:	94 10 20 01 	mov  1, %o2                                    
 201b374:	96 10 00 1a 	mov  %i2, %o3                                  
 201b378:	7f ff dc fb 	call  2012764 <fat_file_extend>                
 201b37c:	98 07 bf fc 	add  %fp, -4, %o4                              
                             fat_fd,                                  
                             true,                                    
                             length,                                  
                             &new_length);                            
        if (rc == RC_OK && length != new_length) {                    
 201b380:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201b384:	12 80 00 0f 	bne  201b3c0 <msdos_file_ftruncate+0xd8>       <== NEVER TAKEN
 201b388:	80 a6 60 00 	cmp  %i1, 0                                    
 201b38c:	12 80 00 05 	bne  201b3a0 <msdos_file_ftruncate+0xb8>       <== NEVER TAKEN
 201b390:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 201b394:	80 a6 80 01 	cmp  %i2, %g1                                  
 201b398:	22 80 00 0a 	be,a   201b3c0 <msdos_file_ftruncate+0xd8>     <== ALWAYS TAKEN
 201b39c:	f4 27 20 18 	st  %i2, [ %i4 + 0x18 ]                        
            fat_file_truncate(&fs_info->fat, fat_fd, old_length);     
 201b3a0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201b3a4:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
 201b3a8:	7f ff dc 49 	call  20124cc <fat_file_truncate>              <== NOT EXECUTED
 201b3ac:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            errno = ENOSPC;                                           
 201b3b0:	40 00 00 7f 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b3b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201b3b8:	82 10 20 1c 	mov  0x1c, %g1                                 <== NOT EXECUTED
 201b3bc:	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);                       
 201b3c0:	7f ff b9 7a 	call  20099a8 <rtems_semaphore_release>        
 201b3c4:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                                                      
    return rc;                                                        
}                                                                     
 201b3c8:	81 c7 e0 08 	ret                                            
 201b3cc:	81 e8 00 00 	restore                                        
                                                                      

0201b0e0 <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) {
 201b0e0:	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;     
 201b0e4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
 201b0e8:	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;     
 201b0ec:	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,        
 201b0f0:	92 10 20 00 	clr  %o1                                       
 201b0f4:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
 201b0f8:	7f ff b9 e3 	call  2009884 <rtems_semaphore_obtain>         
 201b0fc:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201b100:	80 a2 20 00 	cmp  %o0, 0                                    
 201b104:	22 80 00 07 	be,a   201b120 <msdos_file_read+0x40>          <== ALWAYS TAKEN
 201b108:	d4 06 20 0c 	ld  [ %i0 + 0xc ], %o2                         
        rtems_set_errno_and_return_minus_one(EIO);                    
 201b10c:	40 00 01 28 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b110:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
 201b114:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201b118:	10 80 00 10 	b  201b158 <msdos_file_read+0x78>              <== NOT EXECUTED
 201b11c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
    ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,    
 201b120:	98 10 00 19 	mov  %i1, %o4                                  
 201b124:	90 10 00 10 	mov  %l0, %o0                                  
 201b128:	92 10 00 1d 	mov  %i5, %o1                                  
 201b12c:	7f ff dc 7a 	call  2012314 <fat_file_read>                  
 201b130:	96 10 00 1a 	mov  %i2, %o3                                  
                        buffer);                                      
    if (ret > 0)                                                      
 201b134:	b2 92 20 00 	orcc  %o0, 0, %i1                              
 201b138:	04 80 00 06 	ble  201b150 <msdos_file_read+0x70>            
 201b13c:	85 3e 60 1f 	sra  %i1, 0x1f, %g2                            
        iop->offset += ret;                                           
 201b140:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
 201b144:	b6 87 40 19 	addcc  %i5, %i1, %i3                           
 201b148:	b4 47 00 02 	addx  %i4, %g2, %i2                            
 201b14c:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b150:	7f ff ba 16 	call  20099a8 <rtems_semaphore_release>        
 201b154:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
    return ret;                                                       
}                                                                     
 201b158:	81 c7 e0 08 	ret                                            
 201b15c:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                                                      

0201b238 <msdos_file_stat>: int msdos_file_stat( const rtems_filesystem_location_info_t *loc, struct stat *buf ) {
 201b238:	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;              
 201b23c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
 201b240:	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;              
 201b244:	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,        
 201b248:	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;            
 201b24c:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 201b250:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
 201b254:	94 10 20 00 	clr  %o2                                       
 201b258:	7f ff b9 8b 	call  2009884 <rtems_semaphore_obtain>         
 201b25c:	b6 06 ff ff 	add  %i3, -1, %i3                              
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201b260:	80 a2 20 00 	cmp  %o0, 0                                    
 201b264:	22 80 00 08 	be,a   201b284 <msdos_file_stat+0x4c>          <== ALWAYS TAKEN
 201b268:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
        rtems_set_errno_and_return_minus_one(EIO);                    
 201b26c:	40 00 00 d0 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b270:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201b274:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201b278:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 201b27c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b280:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    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;                                    
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b284:	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);
 201b288:	c4 18 40 00 	ldd  [ %g1 ], %g2                              
    buf->st_ino = fat_fd->ino;                                        
 201b28c:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
    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);
 201b290:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    buf->st_ino = fat_fd->ino;                                        
 201b294:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
 201b298:	03 00 00 20 	sethi  %hi(0x8000), %g1                        
 201b29c:	82 10 61 ff 	or  %g1, 0x1ff, %g1	! 81ff <PROM_START+0x81ff> 
 201b2a0:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
 201b2a4:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %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;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
 201b2a8:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
    buf->st_size = fat_fd->fat_file_size;                             
 201b2ac:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
 201b2b0:	82 06 c0 01 	add  %i3, %g1, %g1                             
 201b2b4:	b6 28 40 1b 	andn  %g1, %i3, %i3                            
      >> FAT_SECTOR512_BITS;                                          
    buf->st_blksize = fs_info->fat.vol.bpc;                           
 201b2b8:	c2 17 60 06 	lduh  [ %i5 + 6 ], %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;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
 201b2bc:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    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;                           
 201b2c0:	c2 26 60 40 	st  %g1, [ %i1 + 0x40 ]                        
    buf->st_mtime = fat_fd->mtime;                                    
 201b2c4:	c2 07 20 40 	ld  [ %i4 + 0x40 ], %g1                        
                                                                      
    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;                             
 201b2c8:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
      >> FAT_SECTOR512_BITS;                                          
 201b2cc:	b7 36 e0 09 	srl  %i3, 9, %i3                               
    buf->st_blksize = fs_info->fat.vol.bpc;                           
    buf->st_mtime = fat_fd->mtime;                                    
 201b2d0:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        
    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;                             
    buf->st_blocks = ((fat_fd->fat_file_size + cl_mask) & ~cl_mask)   
 201b2d4:	f6 26 60 44 	st  %i3, [ %i1 + 0x44 ]                        
      >> FAT_SECTOR512_BITS;                                          
    buf->st_blksize = fs_info->fat.vol.bpc;                           
    buf->st_mtime = fat_fd->mtime;                                    
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b2d8:	7f ff b9 b4 	call  20099a8 <rtems_semaphore_release>        
 201b2dc:	b0 10 20 00 	clr  %i0                                       
    return RC_OK;                                                     
}                                                                     
 201b2e0:	81 c7 e0 08 	ret                                            
 201b2e4:	81 e8 00 00 	restore                                        
                                                                      

0201b3d0 <msdos_file_sync>: * RETURNS: * RC_OK on success, or -1 if error occured (errno set appropriately) */ int msdos_file_sync(rtems_libio_t *iop) {
 201b3d0:	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;     
 201b3d4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 201b3d8:	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;     
 201b3dc:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 201b3e0:	94 10 20 00 	clr  %o2                                       
 201b3e4:	7f ff b9 28 	call  2009884 <rtems_semaphore_obtain>         
 201b3e8:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201b3ec:	80 a2 20 00 	cmp  %o0, 0                                    
 201b3f0:	02 80 00 08 	be  201b410 <msdos_file_sync+0x40>             <== ALWAYS TAKEN
 201b3f4:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
 201b3f8:	40 00 00 6d 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b3fc:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 201b400:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201b404:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 201b408:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b40c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    rc = msdos_file_update(iop);                                      
 201b410:	7f ff ff 06 	call  201b028 <msdos_file_update>              
 201b414:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc != RC_OK)                                                  
 201b418:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201b41c:	12 80 00 04 	bne  201b42c <msdos_file_sync+0x5c>            <== NEVER TAKEN
 201b420:	01 00 00 00 	nop                                            
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
 201b424:	7f ff e1 c0 	call  2013b24 <fat_sync>                       
 201b428:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b42c:	7f ff b9 5f 	call  20099a8 <rtems_semaphore_release>        
 201b430:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return RC_OK;                                                     
}                                                                     
 201b434:	81 c7 e0 08 	ret                                            
 201b438:	81 e8 00 00 	restore                                        
                                                                      

0201b028 <msdos_file_update>: #include "msdos.h" static int msdos_file_update(rtems_libio_t *iop) {
 201b028:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int              rc = RC_OK;                                      
    fat_file_fd_t   *fat_fd = iop->pathinfo.node_access;              
 201b02c:	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))                                 
 201b030:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
 201b034:	80 88 60 01 	btst  1, %g1                                   
 201b038:	12 80 00 11 	bne  201b07c <msdos_file_update+0x54>          <== NEVER TAKEN
 201b03c:	90 10 20 00 	clr  %o0                                       
    {                                                                 
        rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
 201b040:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
 201b044:	7f ff f3 d3 	call  2017f90 <msdos_set_first_cluster_num>    
 201b048:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc != RC_OK)                                              
 201b04c:	80 a2 20 00 	cmp  %o0, 0                                    
 201b050:	12 80 00 0b 	bne  201b07c <msdos_file_update+0x54>          <== NEVER TAKEN
 201b054:	01 00 00 00 	nop                                            
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);     
 201b058:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
 201b05c:	7f ff f3 ff 	call  2018058 <msdos_set_file_size>            
 201b060:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc != RC_OK)                                              
 201b064:	80 a2 20 00 	cmp  %o0, 0                                    
 201b068:	12 80 00 05 	bne  201b07c <msdos_file_update+0x54>          <== NEVER TAKEN
 201b06c:	01 00 00 00 	nop                                            
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
 201b070:	f0 06 20 28 	ld  [ %i0 + 0x28 ], %i0                        
 201b074:	7f ff f3 8c 	call  2017ea4 <msdos_set_dir_wrt_time_and_date>
 201b078:	81 e8 00 00 	restore                                        
            return rc;                                                
        }                                                             
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
 201b07c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b080:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

0201b160 <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) {
 201b160:	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;     
 201b164:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
 201b168:	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;     
 201b16c:	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,        
 201b170:	92 10 20 00 	clr  %o1                                       
 201b174:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
 201b178:	7f ff b9 c3 	call  2009884 <rtems_semaphore_obtain>         
 201b17c:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 201b180:	80 a2 20 00 	cmp  %o0, 0                                    
 201b184:	22 80 00 07 	be,a   201b1a0 <msdos_file_write+0x40>         <== ALWAYS TAKEN
 201b188:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
        rtems_set_errno_and_return_minus_one(EIO);                    
 201b18c:	40 00 01 08 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201b190:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
 201b194:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 201b198:	10 80 00 14 	b  201b1e8 <msdos_file_write+0x88>             <== NOT EXECUTED
 201b19c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
    if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)                       
 201b1a0:	80 88 62 00 	btst  0x200, %g1                               
 201b1a4:	22 80 00 06 	be,a   201b1bc <msdos_file_write+0x5c>         
 201b1a8:	d4 06 20 0c 	ld  [ %i0 + 0xc ], %o2                         
        iop->offset = fat_fd->fat_file_size;                          
 201b1ac:	c2 04 60 18 	ld  [ %l1 + 0x18 ], %g1                        
 201b1b0:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
 201b1b4:	c2 26 20 0c 	st  %g1, [ %i0 + 0xc ]                         
                                                                      
    ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,   
 201b1b8:	d4 06 20 0c 	ld  [ %i0 + 0xc ], %o2                         
 201b1bc:	98 10 00 19 	mov  %i1, %o4                                  
 201b1c0:	90 10 00 10 	mov  %l0, %o0                                  
 201b1c4:	92 10 00 11 	mov  %l1, %o1                                  
 201b1c8:	7f ff dd fd 	call  20129bc <fat_file_write>                 
 201b1cc:	96 10 00 1a 	mov  %i2, %o3                                  
                         buffer);                                     
    if (ret < 0)                                                      
 201b1d0:	b2 92 20 00 	orcc  %o0, 0, %i1                              
 201b1d4:	36 80 00 07 	bge,a   201b1f0 <msdos_file_write+0x90>        <== ALWAYS TAKEN
 201b1d8:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
 201b1dc:	7f ff b9 f3 	call  20099a8 <rtems_semaphore_release>        <== NOT EXECUTED
 201b1e0:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        <== NOT EXECUTED
        return -1;                                                    
 201b1e4:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
 201b1e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b1ec:	91 e8 00 19 	restore  %g0, %i1, %o0                         <== NOT EXECUTED
                                                                      
    /*                                                                
     * update file size in both fat-file descriptor and file control block if
     * file was extended                                              
     */                                                               
    iop->offset += ret;                                               
 201b1f0:	b9 3e 60 1f 	sra  %i1, 0x1f, %i4                            
 201b1f4:	86 86 40 1b 	addcc  %i1, %i3, %g3                           
 201b1f8:	84 47 00 1a 	addx  %i4, %i2, %g2                            
 201b1fc:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    if (iop->offset > fat_fd->fat_file_size)                          
 201b200:	80 a0 a0 00 	cmp  %g2, 0                                    
 201b204:	14 80 00 07 	bg  201b220 <msdos_file_write+0xc0>            <== NEVER TAKEN
 201b208:	c2 04 60 18 	ld  [ %l1 + 0x18 ], %g1                        
 201b20c:	80 a0 a0 00 	cmp  %g2, 0                                    
 201b210:	12 80 00 05 	bne  201b224 <msdos_file_write+0xc4>           <== NEVER TAKEN
 201b214:	80 a0 c0 01 	cmp  %g3, %g1                                  
 201b218:	08 80 00 03 	bleu  201b224 <msdos_file_write+0xc4>          
 201b21c:	01 00 00 00 	nop                                            
        fat_fd->fat_file_size = iop->offset;                          
 201b220:	c6 24 60 18 	st  %g3, [ %l1 + 0x18 ]                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201b224:	7f ff b9 e1 	call  20099a8 <rtems_semaphore_release>        
 201b228:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
    return ret;                                                       
}                                                                     
 201b22c:	b0 10 00 19 	mov  %i1, %i0                                  
 201b230:	81 c7 e0 08 	ret                                            
 201b234:	81 e8 00 00 	restore                                        
                                                                      

0201a90c <msdos_filename_unix2dos>: /* * Fill the dos filename string with blanks. These are DOS's pad * characters. */ for (i = 0; i <= 10; i++)
 201a90c:	82 10 20 00 	clr  %g1                                       
		dn[i] = ' ';                                                        
 201a910:	84 10 20 20 	mov  0x20, %g2                                 
 201a914:	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++)                                            
 201a918:	82 00 60 01 	inc  %g1                                       
 201a91c:	80 a0 60 0b 	cmp  %g1, 0xb                                  
 201a920:	32 bf ff fe 	bne,a   201a918 <msdos_filename_unix2dos+0xc>  
 201a924:	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) {                                    
 201a928:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
 201a92c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
 201a930:	12 80 00 12 	bne  201a978 <msdos_filename_unix2dos+0x6c>    <== ALWAYS TAKEN
 201a934:	80 a2 60 00 	cmp  %o1, 0                                    
 201a938:	80 a2 60 01 	cmp  %o1, 1                                    <== NOT EXECUTED
 201a93c:	32 80 00 04 	bne,a   201a94c <msdos_filename_unix2dos+0x40> <== NOT EXECUTED
 201a940:	c2 4a 20 01 	ldsb  [ %o0 + 1 ], %g1                         <== NOT EXECUTED
		dn[0] = '.';                                                        
		return 0;                                                           
 201a944:	10 80 00 4f 	b  201aa80 <msdos_filename_unix2dos+0x174>     <== NOT EXECUTED
 201a948:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              <== NOT EXECUTED
	}                                                                    
	if (un[0] == '.' && un[1] == '.' && unlen == 2) {                    
 201a94c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 <== NOT EXECUTED
 201a950:	12 80 00 0a 	bne  201a978 <msdos_filename_unix2dos+0x6c>    <== NOT EXECUTED
 201a954:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
 201a958:	80 a2 60 02 	cmp  %o1, 2                                    <== NOT EXECUTED
 201a95c:	12 80 00 07 	bne  201a978 <msdos_filename_unix2dos+0x6c>    <== NOT EXECUTED
 201a960:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
		dn[0] = '.';                                                        
 201a964:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              <== NOT EXECUTED
		dn[1] = '.';                                                        
		return 0;                                                           
 201a968:	10 80 00 46 	b  201aa80 <msdos_filename_unix2dos+0x174>     <== NOT EXECUTED
 201a96c:	c2 2a a0 01 	stb  %g1, [ %o2 + 1 ]                          <== NOT EXECUTED
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
		un++;                                                               
		unlen--;                                                            
 201a970:	92 02 7f ff 	add  %o1, -1, %o1                              <== NOT EXECUTED
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
 201a974:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
 201a978:	32 80 00 05 	bne,a   201a98c <msdos_filename_unix2dos+0x80> <== ALWAYS TAKEN
 201a97c:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
                                                                      
	/*                                                                   
	 * Fill the dos filename string with blanks. These are DOS's pad     
	 * characters.                                                       
	 */                                                                  
	for (i = 0; i <= 10; i++)                                            
 201a980:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
	 * of string, a '.', or 8 characters. Whichever happens first stops  
	 * us. This forms the name portion of the dos filename. Fold to      
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
    if (msdos_map[c] == 0)                                            
 201a984:	10 80 00 0d 	b  201a9b8 <msdos_filename_unix2dos+0xac>      
 201a988:	1b 00 80 af 	sethi  %hi(0x202bc00), %o5                     
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
 201a98c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
 201a990:	22 bf ff f8 	be,a   201a970 <msdos_filename_unix2dos+0x64>  <== NEVER TAKEN
 201a994:	90 02 20 01 	inc  %o0                                       <== NOT EXECUTED
                                                                      
	/*                                                                   
	 * Fill the dos filename string with blanks. These are DOS's pad     
	 * characters.                                                       
	 */                                                                  
	for (i = 0; i <= 10; i++)                                            
 201a998:	10 bf ff fb 	b  201a984 <msdos_filename_unix2dos+0x78>      
 201a99c:	82 10 20 00 	clr  %g1                                       
	 * of string, a '.', or 8 characters. Whichever happens first stops  
	 * us. This forms the name portion of the dos filename. Fold to      
	 * upper case.                                                       
	 */                                                                  
	for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {         
    if (msdos_map[c] == 0)                                            
 201a9a0:	c8 0b 00 04 	ldub  [ %o4 + %g4 ], %g4                       
 201a9a4:	80 89 20 ff 	btst  0xff, %g4                                
 201a9a8:	02 80 00 1a 	be  201aa10 <msdos_filename_unix2dos+0x104>    
 201a9ac:	80 a0 a0 00 	cmp  %g2, 0                                    
      break;                                                          
		dn[i] = msdos_map[c];                                               
 201a9b0:	c8 2a 80 01 	stb  %g4, [ %o2 + %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++) {         
 201a9b4:	82 00 60 01 	inc  %g1                                       
 201a9b8:	84 a2 40 01 	subcc  %o1, %g1, %g2                           
 201a9bc:	02 80 00 14 	be  201aa0c <msdos_filename_unix2dos+0x100>    
 201a9c0:	86 02 00 01 	add  %o0, %g1, %g3                             
 201a9c4:	80 a0 60 07 	cmp  %g1, 7                                    
 201a9c8:	04 80 00 03 	ble  201a9d4 <msdos_filename_unix2dos+0xc8>    
 201a9cc:	88 10 20 01 	mov  1, %g4                                    
 201a9d0:	88 10 20 00 	clr  %g4                                       
 201a9d4:	80 89 20 ff 	btst  0xff, %g4                                
 201a9d8:	02 80 00 0e 	be  201aa10 <msdos_filename_unix2dos+0x104>    
 201a9dc:	80 a0 a0 00 	cmp  %g2, 0                                    
 201a9e0:	c8 0a 00 01 	ldub  [ %o0 + %g1 ], %g4                       
 201a9e4:	80 a1 20 00 	cmp  %g4, 0                                    
 201a9e8:	02 80 00 09 	be  201aa0c <msdos_filename_unix2dos+0x100>    <== NEVER TAKEN
 201a9ec:	80 a1 20 2e 	cmp  %g4, 0x2e                                 
 201a9f0:	12 bf ff ec 	bne  201a9a0 <msdos_filename_unix2dos+0x94>    
 201a9f4:	98 13 62 e8 	or  %o5, 0x2e8, %o4                            
                                                                      
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
 201a9f8:	10 80 00 06 	b  201aa10 <msdos_filename_unix2dos+0x104>     
 201a9fc:	80 a0 a0 00 	cmp  %g2, 0                                    
		un++;                                                               
		unlen--;                                                            
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
 201aa00:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
 201aa04:	02 80 00 09 	be  201aa28 <msdos_filename_unix2dos+0x11c>    
 201aa08:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
 201aa0c:	80 a0 a0 00 	cmp  %g2, 0                                    
 201aa10:	02 80 00 07 	be  201aa2c <msdos_filename_unix2dos+0x120>    
 201aa14:	82 10 20 08 	mov  8, %g1                                    
 201aa18:	c2 08 c0 00 	ldub  [ %g3 ], %g1                             
 201aa1c:	80 a0 60 00 	cmp  %g1, 0                                    
 201aa20:	32 bf ff f8 	bne,a   201aa00 <msdos_filename_unix2dos+0xf4> <== ALWAYS TAKEN
 201aa24:	86 00 e0 01 	inc  %g3                                       
                                                                      
	/*                                                                   
	 * Fill the dos filename string with blanks. These are DOS's pad     
	 * characters.                                                       
	 */                                                                  
	for (i = 0; i <= 10; i++)                                            
 201aa28:	82 10 20 08 	mov  8, %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++) {                    
    if (msdos_map[c] == 0)                                            
 201aa2c:	10 80 00 08 	b  201aa4c <msdos_filename_unix2dos+0x140>     
 201aa30:	1b 00 80 af 	sethi  %hi(0x202bc00), %o5                     
 201aa34:	c8 0b 00 04 	ldub  [ %o4 + %g4 ], %g4                       
 201aa38:	80 89 20 ff 	btst  0xff, %g4                                
 201aa3c:	02 80 00 11 	be  201aa80 <msdos_filename_unix2dos+0x174>    
 201aa40:	84 00 bf ff 	add  %g2, -1, %g2                              
      break;                                                          
    dn[i] = msdos_map[c];                                             
 201aa44:	c8 2a 80 01 	stb  %g4, [ %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++) {                    
 201aa48:	82 00 60 01 	inc  %g1                                       
 201aa4c:	80 a0 a0 00 	cmp  %g2, 0                                    
 201aa50:	02 80 00 0c 	be  201aa80 <msdos_filename_unix2dos+0x174>    
 201aa54:	80 a0 60 0a 	cmp  %g1, 0xa                                  
 201aa58:	04 80 00 03 	ble  201aa64 <msdos_filename_unix2dos+0x158>   <== ALWAYS TAKEN
 201aa5c:	88 10 20 01 	mov  1, %g4                                    
 201aa60:	88 10 20 00 	clr  %g4                                       <== NOT EXECUTED
 201aa64:	80 89 20 ff 	btst  0xff, %g4                                
 201aa68:	02 80 00 06 	be  201aa80 <msdos_filename_unix2dos+0x174>    <== NEVER TAKEN
 201aa6c:	88 00 c0 01 	add  %g3, %g1, %g4                             
 201aa70:	c8 09 3f f8 	ldub  [ %g4 + -8 ], %g4                        
 201aa74:	80 a1 20 00 	cmp  %g4, 0                                    
 201aa78:	12 bf ff ef 	bne  201aa34 <msdos_filename_unix2dos+0x128>   <== ALWAYS TAKEN
 201aa7c:	98 13 62 e8 	or  %o5, 0x2e8, %o4                            
    dn[i] = msdos_map[c];                                             
		un++;                                                               
		unlen--;                                                            
	}                                                                    
	return 0;                                                            
}                                                                     
 201aa80:	81 c3 e0 08 	retl                                           
 201aa84:	90 10 20 00 	clr  %o0                                       
                                                                      

020191cc <msdos_find_name>: msdos_find_name( rtems_filesystem_location_info_t *parent_loc, const char *name, int name_len ) {
 20191cc:	9d e3 bf 60 	save  %sp, -160, %sp                           
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
 20191d0:	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);         
 20191d4:	b8 07 bf e0 	add  %fp, -32, %i4                             
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
 20191d8:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
    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);         
 20191dc:	92 10 20 00 	clr  %o1                                       
 20191e0:	94 10 20 20 	mov  0x20, %o2                                 
    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;                                 
 20191e4:	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);         
 20191e8:	40 00 0b ed 	call  201c19c <memset>                         
 20191ec:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    name_type = msdos_long_to_short (name,                            
 20191f0:	92 10 00 1a 	mov  %i2, %o1                                  
 20191f4:	94 10 00 1c 	mov  %i4, %o2                                  
 20191f8:	96 10 20 0b 	mov  0xb, %o3                                  
 20191fc:	7f ff fa 9f 	call  2017c78 <msdos_long_to_short>            
 2019200:	90 10 00 19 	mov  %i1, %o0                                  
msdos_find_name(                                                      
    rtems_filesystem_location_info_t *parent_loc,                     
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
 2019204:	b6 10 00 18 	mov  %i0, %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,                            
 2019208:	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,
 201920c:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        
 2019210:	90 10 00 18 	mov  %i0, %o0                                  
 2019214:	92 10 20 00 	clr  %o1                                       
 2019218:	94 10 00 19 	mov  %i1, %o2                                  
 201921c:	96 10 00 1a 	mov  %i2, %o3                                  
 2019220:	7f ff ff ab 	call  20190cc <msdos_get_name_node>            
 2019224:	9a 07 bf d0 	add  %fp, -48, %o5                             
                             &dir_pos, node_entry);                   
    if (rc != RC_OK)                                                  
 2019228:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201922c:	12 80 00 68 	bne  20193cc <msdos_find_name+0x200>           
 2019230:	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;                              
 2019234:	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) ||     
 2019238:	84 08 60 08 	and  %g1, 8, %g2                               
 201923c:	80 88 a0 ff 	btst  0xff, %g2                                
 2019240:	12 80 00 63 	bne  20193cc <msdos_find_name+0x200>           <== NEVER TAKEN
 2019244:	b0 16 21 01 	or  %i0, 0x101, %i0                            
 2019248:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
 201924c:	80 a0 60 0f 	cmp  %g1, 0xf                                  
 2019250:	02 80 00 5f 	be  20193cc <msdos_find_name+0x200>            <== NEVER TAKEN
 2019254:	90 10 00 1d 	mov  %i5, %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);             
 2019258:	92 07 bf d0 	add  %fp, -48, %o1                             
 201925c:	7f ff e3 cb 	call  2012188 <fat_file_open>                  
 2019260:	94 07 bf cc 	add  %fp, -52, %o2                             
    if (rc != RC_OK)                                                  
 2019264:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2019268:	12 80 00 59 	bne  20193cc <msdos_find_name+0x200>           <== NEVER TAKEN
 201926c:	f8 07 bf cc 	ld  [ %fp + -52 ], %i4                         
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
 2019270:	92 07 bf d0 	add  %fp, -48, %o1                             
 2019274:	90 07 20 20 	add  %i4, 0x20, %o0                            
 2019278:	40 00 0b 8c 	call  201c0a8 <memcpy>                         
 201927c:	94 10 20 10 	mov  0x10, %o2                                 
     * 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)                                       
 2019280:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
 2019284:	80 a0 60 01 	cmp  %g1, 1                                    
 2019288:	32 80 00 49 	bne,a   20193ac <msdos_find_name+0x1e0>        
 201928c:	d2 06 e0 08 	ld  [ %i3 + 8 ], %o1                           
    {                                                                 
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);          
 2019290:	c2 17 bf f4 	lduh  [ %fp + -12 ], %g1                       
 2019294:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2019298:	85 30 60 18 	srl  %g1, 0x18, %g2                            
 201929c:	87 30 60 08 	srl  %g1, 8, %g3                               
 20192a0:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 20192a4:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
 20192a8:	86 08 c0 01 	and  %g3, %g1, %g3                             
 20192ac:	86 10 80 03 	or  %g2, %g3, %g3                              
 20192b0:	c4 17 bf fa 	lduh  [ %fp + -6 ], %g2                        
 20192b4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 20192b8:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20192bc:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
 20192c0:	85 30 a0 08 	srl  %g2, 8, %g2                               
 20192c4:	84 08 80 01 	and  %g2, %g1, %g2                             
 20192c8:	84 11 00 02 	or  %g4, %g2, %g2                              
 20192cc:	84 10 c0 02 	or  %g3, %g2, %g2                              
 20192d0:	c4 27 20 1c 	st  %g2, [ %i4 + 0x1c ]                        
                                                                      
        time_val = *MSDOS_DIR_WRITE_TIME(node_entry);                 
        date = *MSDOS_DIR_WRITE_DATE(node_entry);                     
 20192d4:	c4 17 bf f8 	lduh  [ %fp + -8 ], %g2                        
                                                                      
        fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
 20192d8:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20192dc:	91 30 a0 18 	srl  %g2, 0x18, %o0                            
 20192e0:	85 30 a0 08 	srl  %g2, 8, %g2                               
 20192e4:	86 08 80 01 	and  %g2, %g1, %g3                             
 20192e8:	c4 17 bf f6 	lduh  [ %fp + -10 ], %g2                       
 20192ec:	90 12 00 03 	or  %o0, %g3, %o0                              
 20192f0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20192f4:	93 30 a0 18 	srl  %g2, 0x18, %o1                            
 20192f8:	85 30 a0 08 	srl  %g2, 8, %g2                               
 20192fc:	82 08 80 01 	and  %g2, %g1, %g1                             
 2019300:	40 00 05 3b 	call  201a7ec <msdos_date_dos2unix>            
 2019304:	92 12 40 01 	or  %o1, %g1, %o1                              
                                                                      
        if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)     
 2019308:	c2 0f bf eb 	ldub  [ %fp + -21 ], %g1                       
        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));
 201930c:	d0 27 20 40 	st  %o0, [ %i4 + 0x40 ]                        
                                                                      
        if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)     
 2019310:	82 08 60 10 	and  %g1, 0x10, %g1                            
 2019314:	80 88 60 ff 	btst  0xff, %g1                                
 2019318:	02 80 00 0e 	be  2019350 <msdos_find_name+0x184>            
 201931c:	f8 07 bf cc 	ld  [ %fp + -52 ], %i4                         
        {                                                             
            fat_fd->fat_file_type = FAT_DIRECTORY;                    
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
 2019320:	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;                    
 2019324:	c0 27 20 10 	clr  [ %i4 + 0x10 ]                            
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
 2019328:	c2 27 20 14 	st  %g1, [ %i4 + 0x14 ]                        
                                                                      
            rc = fat_file_size(&fs_info->fat, fat_fd);                
 201932c:	90 10 00 1d 	mov  %i5, %o0                                  
 2019330:	7f ff e6 43 	call  2012c3c <fat_file_size>                  
 2019334:	92 10 00 1c 	mov  %i4, %o1                                  
            if (rc != RC_OK)                                          
 2019338:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201933c:	02 80 00 0d 	be  2019370 <msdos_find_name+0x1a4>            <== ALWAYS TAKEN
 2019340:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
            {                                                         
                fat_file_close(&fs_info->fat, fat_fd);                
 2019344:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2019348:	10 80 00 1f 	b  20193c4 <msdos_find_name+0x1f8>             <== NOT EXECUTED
 201934c:	d2 07 bf cc 	ld  [ %fp + -52 ], %o1                         <== NOT EXECUTED
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
 2019350:	7f ff fa 30 	call  2017c10 <CPU_swap_u32>                   
 2019354:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
            fat_fd->fat_file_type = FAT_FILE;                         
 2019358:	82 10 20 04 	mov  4, %g1                                    
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
 201935c:	d0 27 20 18 	st  %o0, [ %i4 + 0x18 ]                        
            fat_fd->fat_file_type = FAT_FILE;                         
 2019360:	c2 27 20 10 	st  %g1, [ %i4 + 0x10 ]                        
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
 2019364:	82 10 3f ff 	mov  -1, %g1                                   
 2019368:	c2 27 20 14 	st  %g1, [ %i4 + 0x14 ]                        
        }                                                             
                                                                      
        /* these data is not actual for zero-length fat-file */       
        fat_fd->map.file_cln = 0;                                     
 201936c:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
        fat_fd->map.disk_cln = fat_fd->cln;                           
 2019370:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
 2019374:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %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;                                     
 2019378:	c0 20 60 34 	clr  [ %g1 + 0x34 ]                            
        fat_fd->map.disk_cln = fat_fd->cln;                           
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
 201937c:	80 a0 e0 00 	cmp  %g3, 0                                    
 2019380:	02 80 00 08 	be  20193a0 <msdos_find_name+0x1d4>            
 2019384:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
            (fat_fd->fat_file_size <= fs_info->fat.vol.bpc))          
 2019388:	c8 17 60 06 	lduh  [ %i5 + 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) &&                           
 201938c:	80 a0 c0 04 	cmp  %g3, %g4                                  
 2019390:	38 80 00 05 	bgu,a   20193a4 <msdos_find_name+0x1d8>        
 2019394:	84 10 3f ff 	mov  -1, %g2                                   
        {                                                             
            fat_fd->map.last_cln = fat_fd->cln;                       
        }                                                             
        else                                                          
        {                                                             
            fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;               
 2019398:	10 80 00 04 	b  20193a8 <msdos_find_name+0x1dc>             
 201939c:	c4 20 60 3c 	st  %g2, [ %g1 + 0x3c ]                        
 20193a0:	84 10 3f ff 	mov  -1, %g2                                   
 20193a4:	c4 20 60 3c 	st  %g2, [ %g1 + 0x3c ]                        
        }                                                             
    }                                                                 
                                                                      
    /* close fat-file corresponded to the node we searched in */      
    rc = fat_file_close(&fs_info->fat, parent_loc->node_access);      
 20193a8:	d2 06 e0 08 	ld  [ %i3 + 8 ], %o1                           
 20193ac:	7f ff e4 8d 	call  20125e0 <fat_file_close>                 
 20193b0:	90 10 00 1d 	mov  %i5, %o0                                  
    if (rc != RC_OK)                                                  
 20193b4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20193b8:	02 80 00 07 	be  20193d4 <msdos_find_name+0x208>            <== ALWAYS TAKEN
 20193bc:	d2 07 bf cc 	ld  [ %fp + -52 ], %o1                         
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
 20193c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20193c4:	7f ff e4 87 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 20193c8:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20193cc:	81 c7 e0 08 	ret                                            
 20193d0:	81 e8 00 00 	restore                                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* update node_info_ptr field */                                  
    parent_loc->node_access = fat_fd;                                 
 20193d4:	d2 26 e0 08 	st  %o1, [ %i3 + 8 ]                           
                                                                      
    return rc;                                                        
}                                                                     
 20193d8:	81 c7 e0 08 	ret                                            
 20193dc:	81 e8 00 00 	restore                                        
                                                                      

02018320 <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 ) {
 2018320:	9d e3 bf 60 	save  %sp, -160, %sp                           
 2018324:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
 2018328:	84 10 00 1a 	mov  %i2, %g2                                  
 201832c:	e4 07 a0 5c 	ld  [ %fp + 0x5c ], %l2                        
 2018330:	e8 07 a0 60 	ld  [ %fp + 0x60 ], %l4                        
    uint32_t         empty_space_count = 0;                           
    bool             empty_space_found = false;                       
    uint32_t         entries_per_block;                               
    bool             read_cluster = false;                            
                                                                      
    assert(name_len > 0);                                             
 2018334:	80 a7 20 00 	cmp  %i4, 0                                    
 2018338:	14 80 00 0a 	bg  2018360 <msdos_find_name_in_fat_file+0x40> <== ALWAYS TAKEN
 201833c:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
 2018340:	11 00 80 af 	sethi  %hi(0x202bc00), %o0                     <== NOT EXECUTED
 2018344:	15 00 80 af 	sethi  %hi(0x202bc00), %o2                     <== NOT EXECUTED
 2018348:	17 00 80 af 	sethi  %hi(0x202bc00), %o3                     <== NOT EXECUTED
 201834c:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
 2018350:	92 10 23 c9 	mov  0x3c9, %o1                                <== NOT EXECUTED
 2018354:	94 12 a0 f8 	or  %o2, 0xf8, %o2                             <== NOT EXECUTED
 2018358:	10 80 00 3e 	b  2018450 <msdos_find_name_in_fat_file+0x130> <== NOT EXECUTED
 201835c:	96 12 e0 b8 	or  %o3, 0xb8, %o3                             <== 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;                           
 2018360:	82 10 3f ff 	mov  -1, %g1                                   
static inline void                                                    
fat_dir_pos_init(                                                     
    fat_dir_pos_t *dir_pos                                            
    )                                                                 
{                                                                     
  dir_pos->sname.cln = 0;                                             
 2018364:	c0 24 80 00 	clr  [ %l2 ]                                   
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
 2018368:	c2 24 a0 08 	st  %g1, [ %l2 + 8 ]                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
 201836c:	c2 24 a0 0c 	st  %g1, [ %l2 + 0xc ]                         
                                                                      
    fat_dir_pos_init(dir_pos);                                        
                                                                      
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
 2018370:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
 2018374:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
     * 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))               
 2018378:	82 1f 60 01 	xor  %i5, 1, %g1                               
 201837c:	80 a0 00 01 	cmp  %g0, %g1                                  
 2018380:	b4 60 3f ff 	subx  %g0, -1, %i2                             
 2018384:	80 8e a0 ff 	btst  0xff, %i2                                
 2018388:	02 80 00 05 	be  201839c <msdos_find_name_in_fat_file+0x7c> 
 201838c:	c0 24 a0 04 	clr  [ %l2 + 4 ]                               
 2018390:	80 a0 a0 00 	cmp  %g2, 0                                    
 2018394:	12 80 00 08 	bne  20183b4 <msdos_find_name_in_fat_file+0x94>
 2018398:	a6 10 20 00 	clr  %l3                                       
      lfn_entries = 0;                                                
    else                                                              
      lfn_entries =                                                   
 201839c:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         
 20183a0:	90 07 20 0c 	add  %i4, 0xc, %o0                             
 20183a4:	7f ff a8 e7 	call  2002740 <.div>                           
 20183a8:	92 10 20 0d 	mov  0xd, %o1                                  
 20183ac:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
 20183b0:	a6 10 00 08 	mov  %o0, %l3                                  
        ((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
 20183b4:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 20183b8:	80 a0 60 01 	cmp  %g1, 1                                    
 20183bc:	32 80 00 0b 	bne,a   20183e8 <msdos_find_name_in_fat_file+0xc8>
 20183c0:	e2 14 20 06 	lduh  [ %l0 + 6 ], %l1                         
 20183c4:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
 20183c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20183cc:	32 80 00 07 	bne,a   20183e8 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
 20183d0:	e2 14 20 06 	lduh  [ %l0 + 6 ], %l1                         <== NOT EXECUTED
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
 20183d4:	c2 0c 20 0e 	ldub  [ %l0 + 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) &&                                 
 20183d8:	80 88 60 03 	btst  3, %g1                                   
 20183dc:	22 80 00 03 	be,a   20183e8 <msdos_find_name_in_fat_file+0xc8>
 20183e0:	e2 14 20 06 	lduh  [ %l0 + 6 ], %l1                         
 20183e4:	e2 06 60 18 	ld  [ %i1 + 0x18 ], %l1                        
                     * 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 ||                                
 20183e8:	b4 0e a0 ff 	and  %i2, 0xff, %i2                            
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
 20183ec:	82 04 e0 01 	add  %l3, 1, %g1                               
    /*                                                                
     * 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),
 20183f0:	88 10 20 00 	clr  %g4                                       
    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;                       
 20183f4:	c0 2f bf e7 	clrb  [ %fp + -25 ]                            
    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;                           
 20183f8:	b0 10 20 00 	clr  %i0                                       
    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;                           
 20183fc:	ae 10 20 00 	clr  %l7                                       
    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;                          
 2018400:	ac 10 20 00 	clr  %l6                                       
    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;                                   
 2018404:	86 10 20 00 	clr  %g3                                       
    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;                                
 2018408:	c0 2f bf ef 	clrb  [ %fp + -17 ]                            
    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;                             
 201840c:	9a 10 20 00 	clr  %o5                                       
    char                                 *name_dir_entry              
                                )                                     
{                                                                     
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         dir_offset = 0;                                  
 2018410:	b6 10 20 00 	clr  %i3                                       
                     * 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 ||                                
 2018414:	f4 27 bf dc 	st  %i2, [ %fp + -36 ]                         
    /*                                                                
     * 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),
 2018418:	10 80 00 eb 	b  20187c4 <msdos_find_name_in_fat_file+0x4a4> 
 201841c:	c2 27 bf d8 	st  %g1, [ %fp + -40 ]                         
        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)                  
 2018420:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
 2018424:	04 80 02 02 	ble  2018c2c <msdos_find_name_in_fat_file+0x90c><== NEVER TAKEN
 2018428:	80 a2 00 11 	cmp  %o0, %l1                                  
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
 201842c:	22 80 00 0b 	be,a   2018458 <msdos_find_name_in_fat_file+0x138><== ALWAYS TAKEN
 2018430:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        
 2018434:	11 00 80 af 	sethi  %hi(0x202bc00), %o0                     <== NOT EXECUTED
 2018438:	15 00 80 af 	sethi  %hi(0x202bc00), %o2                     <== NOT EXECUTED
 201843c:	17 00 80 af 	sethi  %hi(0x202bc00), %o3                     <== NOT EXECUTED
 2018440:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
 2018444:	92 10 23 f9 	mov  0x3f9, %o1                                <== NOT EXECUTED
 2018448:	94 12 a0 f8 	or  %o2, 0xf8, %o2                             <== NOT EXECUTED
 201844c:	96 12 e0 c8 	or  %o3, 0xc8, %o3                             <== NOT EXECUTED
 2018450:	7f ff f0 b3 	call  201471c <__assert_func>                  <== NOT EXECUTED
 2018454:	01 00 00 00 	nop                                            <== NOT EXECUTED
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (dir_entry = 0;                                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
        {                                                             
            char* entry = (char*) fs_info->cl_buf + dir_entry;        
 2018458:	b4 10 20 00 	clr  %i2	! 0 <PROM_START>                      
             * 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)                               
 201845c:	80 a6 20 00 	cmp  %i0, 0                                    
 2018460:	12 80 00 04 	bne  2018470 <msdos_find_name_in_fat_file+0x150>
 2018464:	de 0d 40 00 	ldub  [ %l5 ], %o7                             
 2018468:	ae 10 00 1a 	mov  %i2, %l7                                  
 201846c:	ac 10 00 1b 	mov  %i3, %l6                                  
            {                                                         
                empty_space_entry = dir_entry;                        
                empty_space_offset = dir_offset;                      
            }                                                         
                                                                      
            if (remainder_empty)                                      
 2018470:	98 8b e0 ff 	andcc  %o7, 0xff, %o4                          
 2018474:	12 80 00 11 	bne  20184b8 <msdos_find_name_in_fat_file+0x198>
 2018478:	80 a3 20 e5 	cmp  %o4, 0xe5                                 
#endif                                                                
                /*                                                    
                 * If just looking and there is no more entries in the
                 * directory - return name-not-found                  
                 */                                                   
                if (!create_node)                                     
 201847c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2018480:	12 80 00 06 	bne  2018498 <msdos_find_name_in_fat_file+0x178>
 2018484:	c4 0f bf e7 	ldub  [ %fp + -25 ], %g2                       
                    return MSDOS_NAME_NOT_FOUND_ERR;                  
 2018488:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
 201848c:	b0 16 21 01 	or  %i0, 0x101, %i0	! 7d01 <PROM_START+0x7d01> 
 2018490:	81 c7 e0 08 	ret                                            
 2018494:	81 e8 00 00 	restore                                        
                 * 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)                               
 2018498:	80 88 a0 ff 	btst  0xff, %g2                                
 201849c:	12 80 00 dc 	bne  201880c <msdos_find_name_in_fat_file+0x4ec>
 20184a0:	80 a7 60 02 	cmp  %i5, 2                                    
        (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;   
 20184a4:	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);
 20184a8:	b5 36 a0 05 	srl  %i2, 5, %i2                               
 20184ac:	b0 06 00 02 	add  %i0, %g2, %i0                             
                 * 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 +=                                
 20184b0:	10 80 00 d7 	b  201880c <msdos_find_name_in_fat_file+0x4ec> 
 20184b4:	b0 26 00 1a 	sub  %i0, %i2, %i0                             
                  printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif                                                                
                }                                                     
                break;                                                
            }                                                         
            else if (entry_empty)                                     
 20184b8:	12 80 00 0c 	bne  20184e8 <msdos_find_name_in_fat_file+0x1c8>
 20184bc:	c2 0f bf e7 	ldub  [ %fp + -25 ], %g1                       
            {                                                         
                if (create_node)                                      
 20184c0:	80 a0 a0 00 	cmp  %g2, 0                                    
 20184c4:	22 80 00 bb 	be,a   20187b0 <msdos_find_name_in_fat_file+0x490>
 20184c8:	b4 06 a0 20 	add  %i2, 0x20, %i2                            
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
 20184cc:	c2 07 bf d8 	ld  [ %fp + -40 ], %g1                         
                if (create_node)                                      
                {                                                     
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
 20184d0:	b0 06 20 01 	inc  %i0                                       
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
 20184d4:	80 a6 00 01 	cmp  %i0, %g1                                  
 20184d8:	32 80 00 b6 	bne,a   20187b0 <msdos_find_name_in_fat_file+0x490>
 20184dc:	b4 06 a0 20 	add  %i2, 0x20, %i2                            
                    empty_space_found = true;                         
 20184e0:	10 80 00 b2 	b  20187a8 <msdos_find_name_in_fat_file+0x488> 
 20184e4:	82 10 20 01 	mov  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)                
 20184e8:	98 18 60 01 	xor  %g1, 1, %o4                               
 20184ec:	80 8b 20 ff 	btst  0xff, %o4                                
 20184f0:	02 80 00 07 	be  201850c <msdos_find_name_in_fat_file+0x1ec><== NEVER TAKEN
 20184f4:	d8 0d 60 0b 	ldub  [ %l5 + 0xb ], %o4                       
 20184f8:	80 a0 a0 00 	cmp  %g2, 0                                    
 20184fc:	02 80 00 04 	be  201850c <msdos_find_name_in_fat_file+0x1ec>
 2018500:	01 00 00 00 	nop                                            
                {                                                     
                    empty_space_entry = 0;                            
                    empty_space_count = 0;                            
 2018504:	b0 10 20 00 	clr  %i0	! 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;                            
 2018508:	ae 10 20 00 	clr  %l7                                       
                                                                      
                /*                                                    
                 * Check the attribute to see if the entry is for a long
                 * file name.                                         
                 */                                                   
                if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) == 
 201850c:	98 0b 20 3f 	and  %o4, 0x3f, %o4                            
 2018510:	80 a3 20 0f 	cmp  %o4, 0xf                                  
 2018514:	12 80 00 54 	bne  2018664 <msdos_find_name_in_fat_file+0x344>
 2018518:	80 8b 60 ff 	btst  0xff, %o5                                
#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)         
 201851c:	d8 07 bf f8 	ld  [ %fp + -8 ], %o4                          
 2018520:	80 a3 3f ff 	cmp  %o4, -1                                   
 2018524:	32 80 00 10 	bne,a   2018564 <msdos_find_name_in_fat_file+0x244>
 2018528:	de 0d 40 00 	ldub  [ %l5 ], %o7                             
                                                                      
                        /*                                            
                         * The first entry must have the last long entry
                         * flag set.                                  
                         */                                           
                        if ((*MSDOS_DIR_ENTRY_TYPE(entry) &           
 201852c:	98 0b e0 40 	and  %o7, 0x40, %o4                            
 2018530:	80 8b 20 ff 	btst  0xff, %o4                                
 2018534:	02 80 00 9e 	be  20187ac <msdos_find_name_in_fat_file+0x48c>
 2018538:	9a 10 20 00 	clr  %o5                                       
                         * 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) &
 201853c:	9e 0b e0 3f 	and  %o7, 0x3f, %o7                            
 2018540:	80 a4 c0 0f 	cmp  %l3, %o7                                  
 2018544:	32 80 00 9b 	bne,a   20187b0 <msdos_find_name_in_fat_file+0x490>
 2018548:	b4 06 a0 20 	add  %i2, 0x20, %i2                            
                            continue;                                 
                                                                      
                        /*                                            
                         * Get the checksum of the short entry.       
                         */                                           
                        lfn_start.cln = dir_offset;                   
 201854c:	f6 27 bf f8 	st  %i3, [ %fp + -8 ]                          
                        lfn_start.ofs = dir_entry;                    
 2018550:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
                        lfn_entry = lfn_entries;                      
                        lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
 2018554:	c6 0d 60 0d 	ldub  [ %l5 + 0xd ], %g3                       
 2018558:	c6 2f bf ef 	stb  %g3, [ %fp + -17 ]                        
 201855c:	86 10 00 13 	mov  %l3, %g3                                  
                     * 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) & 
 2018560:	de 0d 40 00 	ldub  [ %l5 ], %o7                             
 2018564:	9e 0b e0 3f 	and  %o7, 0x3f, %o7                            
 2018568:	80 a0 c0 0f 	cmp  %g3, %o7                                  
 201856c:	12 80 00 07 	bne  2018588 <msdos_find_name_in_fat_file+0x268><== NEVER TAKEN
 2018570:	82 10 3f ff 	mov  -1, %g1                                   
                                       MSDOS_LAST_LONG_ENTRY_MASK)) ||
 2018574:	d8 0f bf ef 	ldub  [ %fp + -17 ], %o4                       
 2018578:	de 0d 60 0d 	ldub  [ %l5 + 0xd ], %o7                       
 201857c:	80 a3 00 0f 	cmp  %o4, %o7                                  
 2018580:	02 80 00 04 	be  2018590 <msdos_find_name_in_fat_file+0x270><== ALWAYS TAKEN
 2018584:	98 00 ff ff 	add  %g3, -1, %o4                              
                    {                                                 
#if MSDOS_FIND_PRINT                                                  
                        printf ("MSFS:[4.4] no match\n");             
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
 2018588:	10 80 00 89 	b  20187ac <msdos_find_name_in_fat_file+0x48c> <== NOT EXECUTED
 201858c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          <== NOT EXECUTED
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
 2018590:	9f 2b 20 02 	sll  %o4, 2, %o7                               
 2018594:	97 2b 20 04 	sll  %o4, 4, %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(                                      
 2018598:	9a 05 60 01 	add  %l5, 1, %o5                               
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
 201859c:	96 22 c0 0f 	sub  %o3, %o7, %o3                             
                    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++)     
 20185a0:	9e 10 20 00 	clr  %o7                                       
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
 20185a4:	96 02 c0 0c 	add  %o3, %o4, %o3                             
                    {                                                 
#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')                               
 20185a8:	d4 4b 40 00 	ldsb  [ %o5 ], %o2                             
 20185ac:	80 a2 a0 00 	cmp  %o2, 0                                    
 20185b0:	12 80 00 0b 	bne  20185dc <msdos_find_name_in_fat_file+0x2bc>
 20185b4:	92 03 c0 0b 	add  %o7, %o3, %o1                             
                            /*                                        
                             * 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) &&   
 20185b8:	80 a0 c0 13 	cmp  %g3, %l3                                  
 20185bc:	12 80 00 22 	bne  2018644 <msdos_find_name_in_fat_file+0x324><== NEVER TAKEN
 20185c0:	80 a3 20 00 	cmp  %o4, 0                                    
                                ((o + i) != name_len))                
 20185c4:	9e 02 c0 0f 	add  %o3, %o7, %o7                             
                            /*                                        
                             * 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) &&   
 20185c8:	80 a3 c0 1c 	cmp  %o7, %i4                                  
 20185cc:	02 80 00 1e 	be  2018644 <msdos_find_name_in_fat_file+0x324><== ALWAYS TAKEN
 20185d0:	80 a3 20 00 	cmp  %o4, 0                                    
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
 20185d4:	10 80 00 0b 	b  2018600 <msdos_find_name_in_fat_file+0x2e0> <== NOT EXECUTED
 20185d8:	86 10 3f ff 	mov  -1, %g3                                   <== NOT EXECUTED
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
 20185dc:	80 a2 40 1c 	cmp  %o1, %i4                                  
 20185e0:	16 80 00 07 	bge  20185fc <msdos_find_name_in_fat_file+0x2dc>
 20185e4:	c2 07 a0 50 	ld  [ %fp + 0x50 ], %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(                                      
 20185e8:	92 00 40 0b 	add  %g1, %o3, %o1                             
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
                            break;                                    
                        }                                             
                                                                      
                        if (((o + i) >= name_len) || (*p != name[o + i]))
 20185ec:	d2 4a 40 0f 	ldsb  [ %o1 + %o7 ], %o1                       
 20185f0:	80 a2 80 09 	cmp  %o2, %o1                                  
 20185f4:	02 80 00 05 	be  2018608 <msdos_find_name_in_fat_file+0x2e8>
 20185f8:	80 a3 e0 04 	cmp  %o7, 4                                    
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
 20185fc:	86 10 3f ff 	mov  -1, %g3                                   
                            break;                                    
 2018600:	10 80 00 10 	b  2018640 <msdos_find_name_in_fat_file+0x320> 
 2018604:	c6 27 bf f8 	st  %g3, [ %fp + -8 ]                          
                        }                                             
                                                                      
                        switch (i)                                    
 2018608:	02 80 00 06 	be  2018620 <msdos_find_name_in_fat_file+0x300>
 201860c:	80 a3 e0 0a 	cmp  %o7, 0xa                                  
 2018610:	32 80 00 08 	bne,a   2018630 <msdos_find_name_in_fat_file+0x310>
 2018614:	9a 03 60 02 	add  %o5, 2, %o5                               
                        {                                             
                            case 4:                                   
                                p += 5;                               
                                break;                                
                            case 10:                                  
                                p += 4;                               
 2018618:	10 80 00 04 	b  2018628 <msdos_find_name_in_fat_file+0x308> 
 201861c:	9a 03 60 04 	add  %o5, 4, %o5                               
                                                                      
                        switch (i)                                    
                        {                                             
                            case 4:                                   
                                p += 5;                               
                                break;                                
 2018620:	10 80 00 04 	b  2018630 <msdos_find_name_in_fat_file+0x310> 
 2018624:	9a 03 60 05 	add  %o5, 5, %o5                               
                            case 10:                                  
                                p += 4;                               
                                break;                                
 2018628:	10 80 00 03 	b  2018634 <msdos_find_name_in_fat_file+0x314> 
 201862c:	9e 03 e0 01 	inc  %o7                                       
                    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++)     
 2018630:	9e 03 e0 01 	inc  %o7                                       
 2018634:	80 a3 e0 0d 	cmp  %o7, 0xd                                  
 2018638:	32 bf ff dd 	bne,a   20185ac <msdos_find_name_in_fat_file+0x28c>
 201863c:	d4 4b 40 00 	ldsb  [ %o5 ], %o2                             
                                p += 2;                               
                                break;                                
                        }                                             
                    }                                                 
                                                                      
                    lfn_matched = ((lfn_entry == 0) &&                
 2018640:	80 a3 20 00 	cmp  %o4, 0                                    
 2018644:	12 80 00 06 	bne  201865c <msdos_find_name_in_fat_file+0x33c>
 2018648:	9a 10 20 00 	clr  %o5                                       
 201864c:	c6 07 bf f8 	ld  [ %fp + -8 ], %g3                          
 2018650:	86 38 00 03 	xnor  %g0, %g3, %g3                            
 2018654:	80 a0 00 03 	cmp  %g0, %g3                                  
 2018658:	9a 40 20 00 	addx  %g0, 0, %o5                              
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
 201865c:	10 80 00 54 	b  20187ac <msdos_find_name_in_fat_file+0x48c> 
 2018660:	86 10 00 0c 	mov  %o4, %g3                                  
                     * 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)                                  
 2018664:	02 80 01 85 	be  2018c78 <msdos_find_name_in_fat_file+0x958>
 2018668:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 201866c:	9a 10 20 00 	clr  %o5                                       
 2018670:	9e 10 20 00 	clr  %o7                                       
                        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;
 2018674:	d6 0d 40 0d 	ldub  [ %l5 + %o5 ], %o3                       
 2018678:	98 0b e0 01 	and  %o7, 1, %o4                               
 201867c:	80 a0 00 0c 	cmp  %g0, %o4                                  
 2018680:	9e 0b e0 ff 	and  %o7, 0xff, %o7                            
 2018684:	98 40 3f ff 	addx  %g0, -1, %o4                             
 2018688:	9f 33 e0 01 	srl  %o7, 1, %o7                               
 201868c:	98 0b 20 80 	and  %o4, 0x80, %o4                            
 2018690:	9e 02 c0 0f 	add  %o3, %o7, %o7                             
 2018694:	98 03 3f 80 	add  %o4, -128, %o4                            
                    {                                                 
                        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++)
 2018698:	9a 03 60 01 	inc  %o5                                       
 201869c:	80 a3 60 0b 	cmp  %o5, 0xb                                  
 20186a0:	12 bf ff f5 	bne  2018674 <msdos_find_name_in_fat_file+0x354>
 20186a4:	9e 03 c0 0c 	add  %o7, %o4, %o7                             
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
                                                                      
                        if (lfn_entry || (lfn_checksum != cs))        
 20186a8:	c2 0f bf ef 	ldub  [ %fp + -17 ], %g1                       
 20186ac:	9e 1b c0 01 	xor  %o7, %g1, %o7                             
 20186b0:	80 8b e0 ff 	btst  0xff, %o7                                
 20186b4:	12 80 01 71 	bne  2018c78 <msdos_find_name_in_fat_file+0x958><== NEVER TAKEN
 20186b8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 20186bc:	80 a0 e0 00 	cmp  %g3, 0                                    
 20186c0:	12 80 01 6f 	bne  2018c7c <msdos_find_name_in_fat_file+0x95c><== NEVER TAKEN
 20186c4:	80 a0 60 00 	cmp  %g1, 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,
 20186c8:	90 10 00 10 	mov  %l0, %o0                                  
 20186cc:	92 10 00 19 	mov  %i1, %o1                                  
 20186d0:	94 10 20 01 	mov  1, %o2                                    
 20186d4:	96 10 00 04 	mov  %g4, %o3                                  
 20186d8:	7f ff e7 ef 	call  2012694 <fat_file_ioctl>                 
 20186dc:	98 10 00 12 	mov  %l2, %o4                                  
                                                dir_offset * bts2rd,  
                                                &dir_pos->sname.cln); 
                        if (rc != RC_OK)                              
 20186e0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20186e4:	02 80 00 13 	be  2018730 <msdos_find_name_in_fat_file+0x410><== ALWAYS TAKEN
 20186e8:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
 20186ec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20186f0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                     * 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) &&           
 20186f4:	80 a3 ff ff 	cmp  %o7, -1                                   
 20186f8:	12 80 00 29 	bne  201879c <msdos_find_name_in_fat_file+0x47c><== NEVER TAKEN
 20186fc:	82 10 3f ff 	mov  -1, %g1                                   
                         (lfn_start.cln == FAT_FILE_SHORT_NAME) &&    
                         (memcmp(MSDOS_DIR_NAME(entry),               
 2018700:	c4 3f bf d0 	std  %g2, [ %fp + -48 ]                        
 2018704:	c8 27 bf cc 	st  %g4, [ %fp + -52 ]                         
 2018708:	90 10 00 15 	mov  %l5, %o0                                  
 201870c:	92 10 00 14 	mov  %l4, %o1                                  
 2018710:	40 00 0e 3c 	call  201c000 <memcmp>                         
 2018714:	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) &&    
 2018718:	c4 1f bf d0 	ldd  [ %fp + -48 ], %g2                        
 201871c:	80 a2 20 00 	cmp  %o0, 0                                    
 2018720:	12 80 00 1e 	bne  2018798 <msdos_find_name_in_fat_file+0x478>
 2018724:	c8 07 bf cc 	ld  [ %fp + -52 ], %g4                         
#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,
 2018728:	10 bf ff e9 	b  20186cc <msdos_find_name_in_fat_file+0x3ac> 
 201872c:	90 10 00 10 	mov  %l0, %o0                                  
                        if (rc != RC_OK)                              
                            return rc;                                
                                                                      
                        dir_pos->sname.ofs = dir_entry;               
                                                                      
                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)     
 2018730:	80 a2 7f ff 	cmp  %o1, -1                                   
 2018734:	12 80 00 0c 	bne  2018764 <msdos_find_name_in_fat_file+0x444>
 2018738:	f4 24 a0 04 	st  %i2, [ %l2 + 4 ]                           
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
 201873c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
 2018740:	90 10 00 14 	mov  %l4, %o0                                  
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
 2018744:	c2 24 a0 08 	st  %g1, [ %l2 + 8 ]                           
                        dir_pos->lname.ofs = lfn_start.ofs;           
 2018748:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                        memcpy(name_dir_entry, entry,                 
 201874c:	92 10 00 15 	mov  %l5, %o1                                  
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
                        dir_pos->lname.ofs = lfn_start.ofs;           
 2018750:	c2 24 a0 0c 	st  %g1, [ %l2 + 0xc ]                         
                                                                      
                        memcpy(name_dir_entry, entry,                 
 2018754:	40 00 0e 55 	call  201c0a8 <memcpy>                         
 2018758:	94 10 20 20 	mov  0x20, %o2                                 
 201875c:	81 c7 e0 08 	ret                                            
 2018760:	81 e8 00 00 	restore                                        
                                                                      
                        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,
 2018764:	7f ff a7 bb 	call  2002650 <.umul>                          
 2018768:	90 10 00 11 	mov  %l1, %o0                                  
 201876c:	92 10 00 19 	mov  %i1, %o1                                  
 2018770:	96 10 00 08 	mov  %o0, %o3                                  
 2018774:	94 10 20 01 	mov  1, %o2                                    
 2018778:	90 10 00 10 	mov  %l0, %o0                                  
 201877c:	7f ff e7 c6 	call  2012694 <fat_file_ioctl>                 
 2018780:	98 07 bf f8 	add  %fp, -8, %o4                              
                                              lfn_start.cln * bts2rd, 
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
 2018784:	80 a2 20 00 	cmp  %o0, 0                                    
 2018788:	12 80 01 37 	bne  2018c64 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
 201878c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
 2018790:	10 bf ff ed 	b  2018744 <msdos_find_name_in_fat_file+0x424> 
 2018794:	90 10 00 14 	mov  %l4, %o0                                  
                               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);    
                        return RC_OK;                                 
                    }                                                 
                                                                      
                    lfn_start.cln = FAT_FILE_SHORT_NAME;              
 2018798:	82 10 3f ff 	mov  -1, %g1                                   
                    lfn_matched = false;                              
 201879c:	9a 10 20 00 	clr  %o5                                       
                        memcpy(name_dir_entry, entry,                 
                               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);    
                        return RC_OK;                                 
                    }                                                 
                                                                      
                    lfn_start.cln = FAT_FILE_SHORT_NAME;              
 20187a0:	10 80 00 03 	b  20187ac <msdos_find_name_in_fat_file+0x48c> 
 20187a4:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
                    empty_space_found = true;                         
 20187a8:	c2 2f bf e7 	stb  %g1, [ %fp + -25 ]                        
        assert(ret == bts2rd);                                        
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (dir_entry = 0;                                           
             dir_entry < bts2rd;                                      
             dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)          
 20187ac:	b4 06 a0 20 	add  %i2, 0x20, %i2                            
            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;                                           
 20187b0:	80 a6 80 11 	cmp  %i2, %l1                                  
 20187b4:	0a bf ff 2a 	bcs  201845c <msdos_find_name_in_fat_file+0x13c>
 20187b8:	aa 05 60 20 	add  %l5, 0x20, %l5                            
        }                                                             
                                                                      
        if (remainder_empty)                                          
            break;                                                    
                                                                      
        dir_offset++;                                                 
 20187bc:	b6 06 e0 01 	inc  %i3                                       
 20187c0:	88 01 00 11 	add  %g4, %l1, %g4                             
    /*                                                                
     * 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),
 20187c4:	d8 04 20 a0 	ld  [ %l0 + 0xa0 ], %o4                        
 20187c8:	94 10 00 04 	mov  %g4, %o2                                  
 20187cc:	c4 3f bf d0 	std  %g2, [ %fp + -48 ]                        
 20187d0:	c8 27 bf cc 	st  %g4, [ %fp + -52 ]                         
 20187d4:	da 27 bf c4 	st  %o5, [ %fp + -60 ]                         
 20187d8:	90 10 00 10 	mov  %l0, %o0                                  
 20187dc:	92 10 00 19 	mov  %i1, %o1                                  
 20187e0:	7f ff e6 cd 	call  2012314 <fat_file_read>                  
 20187e4:	96 10 00 11 	mov  %l1, %o3                                  
 20187e8:	c4 1f bf d0 	ldd  [ %fp + -48 ], %g2                        
 20187ec:	80 a2 20 00 	cmp  %o0, 0                                    
 20187f0:	c8 07 bf cc 	ld  [ %fp + -52 ], %g4                         
 20187f4:	12 bf ff 0b 	bne  2018420 <msdos_find_name_in_fat_file+0x100>
 20187f8:	da 07 bf c4 	ld  [ %fp + -60 ], %o5                         
    }                                                                 
                                                                      
    /*                                                                
     * If we are not to create the entry return a not found error.    
     */                                                               
    if (!create_node)                                                 
 20187fc:	80 a0 a0 00 	cmp  %g2, 0                                    
 2018800:	22 bf ff 23 	be,a   201848c <msdos_find_name_in_fat_file+0x16c>
 2018804:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
     * 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)                                 
 2018808:	80 a7 60 02 	cmp  %i5, 2                                    
 201880c:	12 80 00 2e 	bne  20188c4 <msdos_find_name_in_fat_file+0x5a4>
 2018810:	80 a4 e0 00 	cmp  %l3, 0                                    
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
 2018814:	90 10 00 16 	mov  %l6, %o0                                  
 2018818:	7f ff a7 8e 	call  2002650 <.umul>                          
 201881c:	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 == '.'))                                 
 2018820:	c4 4d 00 00 	ldsb  [ %l4 ], %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;
 2018824:	ba 04 e0 01 	add  %l3, 1, %i5                               
     * in this directory.                                             
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
 2018828:	90 02 00 17 	add  %o0, %l7, %o0                             
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
 201882c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
     * in this directory.                                             
     */                                                               
    lfn_checksum = 0;                                                 
    if (name_type == MSDOS_NAME_LONG)                                 
    {                                                                 
        int      slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
 2018830:	91 32 20 05 	srl  %o0, 5, %o0                               
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
 2018834:	02 80 00 05 	be  2018848 <msdos_find_name_in_fat_file+0x528><== NEVER TAKEN
 2018838:	ba 07 40 08 	add  %i5, %o0, %i5                             
 201883c:	80 a0 a0 20 	cmp  %g2, 0x20                                 
 2018840:	32 80 00 05 	bne,a   2018854 <msdos_find_name_in_fat_file+0x534>
 2018844:	c4 4d 20 01 	ldsb  [ %l4 + 1 ], %g2                         
        *c = '_';                                                     
 2018848:	84 10 20 5f 	mov  0x5f, %g2                                 
 201884c:	c4 2d 00 00 	stb  %g2, [ %l4 ]                              
{                                                                     
    static const char* hex = "0123456789ABCDEF";                      
    char* c = MSDOS_DIR_NAME(sfn);                                    
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
 2018850:	c4 4d 20 01 	ldsb  [ %l4 + 1 ], %g2                         
 2018854:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
 2018858:	22 80 00 06 	be,a   2018870 <msdos_find_name_in_fat_file+0x550><== NEVER TAKEN
 201885c:	84 10 20 5f 	mov  0x5f, %g2                                 <== NOT EXECUTED
 2018860:	80 a0 a0 20 	cmp  %g2, 0x20                                 
 2018864:	12 80 00 05 	bne  2018878 <msdos_find_name_in_fat_file+0x558>
 2018868:	86 05 20 02 	add  %l4, 2, %g3                               
        *c = '_';                                                     
 201886c:	84 10 20 5f 	mov  0x5f, %g2                                 
 2018870:	c4 2d 20 01 	stb  %g2, [ %l4 + 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++)                                      
 2018874:	86 05 20 02 	add  %l4, 2, %g3                               
 2018878:	84 10 20 00 	clr  %g2                                       
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '_';                                                     
    for (i = 0; i < 4; i++, c++)                                      
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
 201887c:	35 00 80 ac 	sethi  %hi(0x202b000), %i2                     
 *     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(                                      
 2018880:	88 20 00 02 	neg  %g2, %g4                                  
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '_';                                                     
    for (i = 0; i < 4; i++, c++)                                      
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
 2018884:	b8 16 a3 b0 	or  %i2, 0x3b0, %i4                            
 *     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(                                      
 2018888:	89 29 20 02 	sll  %g4, 2, %g4                               
 201888c:	88 01 20 0c 	add  %g4, 0xc, %g4                             
    int   i;                                                          
    for (i = 0; i < 2; i++, c++)                                      
      if ((*c == ' ') || (*c == '.'))                                 
        *c = '_';                                                     
    for (i = 0; i < 4; i++, c++)                                      
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
 2018890:	89 3f 40 04 	sra  %i5, %g4, %g4                             
 2018894:	88 09 20 0f 	and  %g4, 0xf, %g4                             
 2018898:	c8 0f 00 04 	ldub  [ %i4 + %g4 ], %g4                       
 201889c:	c8 28 c0 02 	stb  %g4, [ %g3 + %g2 ]                        
    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++)                                      
 20188a0:	84 00 a0 01 	inc  %g2                                       
 20188a4:	80 a0 a0 04 	cmp  %g2, 4                                    
 20188a8:	12 bf ff f8 	bne  2018888 <msdos_find_name_in_fat_file+0x568>
 20188ac:	88 20 00 02 	neg  %g2, %g4                                  
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
    *c++ = '~';                                                       
 20188b0:	84 10 20 7e 	mov  0x7e, %g2                                 
 20188b4:	c4 2d 20 06 	stb  %g2, [ %l4 + 6 ]                          
    *c++ = '1';                                                       
 20188b8:	84 10 20 31 	mov  0x31, %g2                                 
 20188bc:	c4 2d 20 07 	stb  %g2, [ %l4 + 7 ]                          
        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)                                                  
 20188c0:	80 a4 e0 00 	cmp  %l3, 0                                    
 20188c4:	02 80 00 10 	be  2018904 <msdos_find_name_in_fat_file+0x5e4>
 20188c8:	b8 10 20 00 	clr  %i4                                       
 20188cc:	84 10 20 00 	clr  %g2                                       
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
            lfn_checksum =                                            
 20188d0:	c8 0d 00 02 	ldub  [ %l4 + %g2 ], %g4                       
 20188d4:	86 0f 20 01 	and  %i4, 1, %g3                               
 20188d8:	80 a0 00 03 	cmp  %g0, %g3                                  
 20188dc:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
 20188e0:	86 40 3f ff 	addx  %g0, -1, %g3                             
 20188e4:	b9 37 20 01 	srl  %i4, 1, %i4                               
 20188e8:	86 08 e0 80 	and  %g3, 0x80, %g3                            
 20188ec:	b8 01 00 1c 	add  %g4, %i4, %i4                             
 20188f0:	86 00 ff 80 	add  %g3, -128, %g3                            
                                                                      
    if (lfn_entries)                                                  
    {                                                                 
        uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);       
        int      i;                                                   
        for (i = 0; i < 11; i++, p++)                                 
 20188f4:	84 00 a0 01 	inc  %g2                                       
 20188f8:	80 a0 a0 0b 	cmp  %g2, 0xb                                  
 20188fc:	12 bf ff f5 	bne  20188d0 <msdos_find_name_in_fat_file+0x5b0>
 2018900:	b8 07 00 03 	add  %i4, %g3, %i4                             
     * 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)                                       
 2018904:	80 a6 20 00 	cmp  %i0, 0                                    
 2018908:	22 80 00 06 	be,a   2018920 <msdos_find_name_in_fat_file+0x600>
 201890c:	ac 10 00 1b 	mov  %i3, %l6                                  
    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;                            
 2018910:	82 1e c0 16 	xor  %i3, %l6, %g1                             
 2018914:	80 a0 00 01 	cmp  %g0, %g1                                  
 2018918:	10 80 00 04 	b  2018928 <msdos_find_name_in_fat_file+0x608> 
 201891c:	b4 40 20 00 	addx  %g0, 0, %i2                              
     * be at the next cluster so we can just make empty_space_offset  
     * that value.                                                    
     */                                                               
    if (empty_space_count == 0)                                       
    {                                                                 
        read_cluster = true;                                          
 2018920:	b4 10 20 01 	mov  1, %i2                                    
        empty_space_offset = dir_offset;                              
        empty_space_entry = 0;                                        
 2018924:	ae 10 20 00 	clr  %l7                                       
        read_cluster = true;                                          
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
 2018928:	84 10 3f ff 	mov  -1, %g2                                   
 201892c:	90 10 00 16 	mov  %l6, %o0                                  
 2018930:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
 2018934:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
 2018938:	7f ff a7 46 	call  2002650 <.umul>                          
 201893c:	92 10 00 11 	mov  %l1, %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(                                      
 2018940:	c6 07 a0 50 	ld  [ %fp + 0x50 ], %g3                        
 2018944:	83 2c e0 02 	sll  %l3, 2, %g1                               
 2018948:	85 2c e0 04 	sll  %l3, 4, %g2                               
 201894c:	82 20 80 01 	sub  %g2, %g1, %g1                             
 2018950:	82 00 40 13 	add  %g1, %l3, %g1                             
 2018954:	82 00 c0 01 	add  %g3, %g1, %g1                             
 2018958:	ba 10 00 08 	mov  %o0, %i5                                  
 201895c:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]                         
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
    lfn_entry = 0;                                                    
 2018960:	b0 10 20 00 	clr  %i0                                       
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
 2018964:	82 04 e0 01 	add  %l3, 1, %g1                               
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
 2018968:	10 80 00 ba 	b  2018c50 <msdos_find_name_in_fat_file+0x930> 
 201896c:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
    {                                                                 
        int length = 0;                                               
                                                                      
        if (read_cluster)                                             
 2018970:	02 80 00 2f 	be  2018a2c <msdos_find_name_in_fat_file+0x70c>
 2018974:	c6 07 bf e4 	ld  [ %fp + -28 ], %g3                         
        {                                                             
          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,                  
 2018978:	d8 04 20 a0 	ld  [ %l0 + 0xa0 ], %o4                        
 201897c:	90 10 00 10 	mov  %l0, %o0                                  
 2018980:	92 10 00 19 	mov  %i1, %o1                                  
 2018984:	94 10 00 1d 	mov  %i5, %o2                                  
 2018988:	7f ff e6 63 	call  2012314 <fat_file_read>                  
 201898c:	96 10 00 11 	mov  %l1, %o3                                  
                              (empty_space_offset * bts2rd), bts2rd,  
                              fs_info->cl_buf);                       
                                                                      
          if (ret != bts2rd)                                          
 2018990:	80 a2 00 11 	cmp  %o0, %l1                                  
 2018994:	02 80 00 25 	be  2018a28 <msdos_find_name_in_fat_file+0x708><== NEVER TAKEN
 2018998:	80 a2 20 00 	cmp  %o0, 0                                    
          {                                                           
            if (ret != FAT_EOF)                                       
 201899c:	22 80 00 03 	be,a   20189a8 <msdos_find_name_in_fat_file+0x688><== ALWAYS TAKEN
 20189a0:	90 10 00 10 	mov  %l0, %o0                                  
 20189a4:	30 80 00 1b 	b,a   2018a10 <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
                                                                      
#if MSDOS_FIND_PRINT                                                  
            printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif                                                                
            ret = fat_file_extend (&fs_info->fat, fat_fd, false,      
 20189a8:	92 10 00 19 	mov  %i1, %o1                                  
 20189ac:	94 10 20 00 	clr  %o2                                       
 20189b0:	96 10 00 1d 	mov  %i5, %o3                                  
 20189b4:	7f ff e7 6c 	call  2012764 <fat_file_extend>                
 20189b8:	98 07 bf f4 	add  %fp, -12, %o4                             
                                   empty_space_offset * bts2rd, &new_length);
                                                                      
            if (ret != RC_OK)                                         
 20189bc:	80 a2 20 00 	cmp  %o0, 0                                    
 20189c0:	12 80 00 a9 	bne  2018c64 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
 20189c4:	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))          
 20189c8:	80 a0 40 1d 	cmp  %g1, %i5                                  
 20189cc:	22 80 00 03 	be,a   20189d8 <msdos_find_name_in_fat_file+0x6b8><== ALWAYS TAKEN
 20189d0:	d0 04 20 a0 	ld  [ %l0 + 0xa0 ], %o0                        
 20189d4:	30 80 00 0f 	b,a   2018a10 <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
                                                                      
            memset(fs_info->cl_buf, 0, bts2rd);                       
 20189d8:	92 10 20 00 	clr  %o1                                       
 20189dc:	40 00 0d f0 	call  201c19c <memset>                         
 20189e0:	94 10 00 11 	mov  %l1, %o2                                  
                                                                      
            ret = fat_file_write(&fs_info->fat, fat_fd,               
 20189e4:	d8 04 20 a0 	ld  [ %l0 + 0xa0 ], %o4                        
 20189e8:	90 10 00 10 	mov  %l0, %o0                                  
 20189ec:	92 10 00 19 	mov  %i1, %o1                                  
 20189f0:	94 10 00 1d 	mov  %i5, %o2                                  
 20189f4:	7f ff e7 f2 	call  20129bc <fat_file_write>                 
 20189f8:	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)                                            
 20189fc:	80 a2 3f ff 	cmp  %o0, -1                                   
 2018a00:	02 80 00 99 	be  2018c64 <msdos_find_name_in_fat_file+0x944><== ALWAYS TAKEN
 2018a04:	80 a2 00 11 	cmp  %o0, %l1                                  
              return ret;                                             
            else if (ret != bts2rd)                                   
 2018a08:	02 80 00 09 	be  2018a2c <msdos_find_name_in_fat_file+0x70c><== NOT EXECUTED
 2018a0c:	c6 07 bf e4 	ld  [ %fp + -28 ], %g3                         <== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
 2018a10:	40 00 0a e7 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2018a14:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2018a18:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
 2018a1c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2018a20:	10 80 00 91 	b  2018c64 <msdos_find_name_in_fat_file+0x944> <== NOT EXECUTED
 2018a24:	90 10 3f ff 	mov  -1, %o0                                   <== 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(                                      
 2018a28:	c6 07 bf e4 	ld  [ %fp + -28 ], %g3                         <== NOT EXECUTED
 2018a2c:	83 2e 20 02 	sll  %i0, 2, %g1                               
 2018a30:	97 2e 20 04 	sll  %i0, 4, %o3                               
 2018a34:	84 06 20 01 	add  %i0, 1, %g2                               
 2018a38:	96 22 c0 01 	sub  %o3, %g1, %o3                             
 2018a3c:	9a 10 20 00 	clr  %o5                                       
 2018a40:	96 02 c0 18 	add  %o3, %i0, %o3                             
 2018a44:	b4 10 20 00 	clr  %i2                                       
 2018a48:	96 20 c0 0b 	sub  %g3, %o3, %o3                             
 2018a4c:	10 80 00 68 	b  2018bec <msdos_find_name_in_fat_file+0x8cc> 
 2018a50:	96 02 ff f3 	add  %o3, -13, %o3                             
                                                                      
        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;  
 2018a54:	d8 04 20 a0 	ld  [ %l0 + 0xa0 ], %o4                        
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
 2018a58:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
                                                                      
        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;  
 2018a5c:	aa 03 00 1b 	add  %o4, %i3, %l5                             
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
 2018a60:	b4 06 a0 20 	add  %i2, 0x20, %i2                            
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
 2018a64:	80 a0 80 01 	cmp  %g2, %g1                                  
 2018a68:	12 80 00 25 	bne  2018afc <msdos_find_name_in_fat_file+0x7dc>
 2018a6c:	b0 10 00 02 	mov  %g2, %i0                                  
            {                                                         
                /* get current cluster number */                      
                int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
 2018a70:	90 10 00 10 	mov  %l0, %o0                                  
 2018a74:	92 10 00 19 	mov  %i1, %o1                                  
 2018a78:	94 10 20 01 	mov  1, %o2                                    
 2018a7c:	96 10 00 1d 	mov  %i5, %o3                                  
 2018a80:	7f ff e7 05 	call  2012694 <fat_file_ioctl>                 
 2018a84:	98 10 00 12 	mov  %l2, %o4                                  
                                        empty_space_offset * bts2rd,  
                                        &dir_pos->sname.cln);         
                if (rc != RC_OK)                                      
 2018a88:	80 a2 20 00 	cmp  %o0, 0                                    
 2018a8c:	12 80 00 76 	bne  2018c64 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
 2018a90:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
                  return rc;                                          
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
 2018a94:	80 a2 7f ff 	cmp  %o1, -1                                   
 2018a98:	12 80 00 0c 	bne  2018ac8 <msdos_find_name_in_fat_file+0x7a8>
 2018a9c:	f6 24 a0 04 	st  %i3, [ %l2 + 4 ]                           
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
 2018aa0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                dir_pos->lname.ofs = lfn_start.ofs;                   
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
 2018aa4:	90 10 00 15 	mov  %l5, %o0                                  
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
 2018aa8:	c2 24 a0 08 	st  %g1, [ %l2 + 8 ]                           
                dir_pos->lname.ofs = lfn_start.ofs;                   
 2018aac:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
 2018ab0:	92 10 00 14 	mov  %l4, %o1                                  
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
                dir_pos->lname.ofs = lfn_start.ofs;                   
 2018ab4:	c2 24 a0 0c 	st  %g1, [ %l2 + 0xc ]                         
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
 2018ab8:	40 00 0d 7c 	call  201c0a8 <memcpy>                         
 2018abc:	94 10 20 20 	mov  0x20, %o2                                 
                        MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);           
                break;                                                
 2018ac0:	10 80 00 50 	b  2018c00 <msdos_find_name_in_fat_file+0x8e0> 
 2018ac4:	d8 04 20 a0 	ld  [ %l0 + 0xa0 ], %o4                        
                                                                      
                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,
 2018ac8:	7f ff a6 e2 	call  2002650 <.umul>                          
 2018acc:	90 10 00 11 	mov  %l1, %o0                                  
 2018ad0:	92 10 00 19 	mov  %i1, %o1                                  
 2018ad4:	96 10 00 08 	mov  %o0, %o3                                  
 2018ad8:	94 10 20 01 	mov  1, %o2                                    
 2018adc:	90 10 00 10 	mov  %l0, %o0                                  
 2018ae0:	7f ff e6 ed 	call  2012694 <fat_file_ioctl>                 
 2018ae4:	98 07 bf f8 	add  %fp, -8, %o4                              
                                      lfn_start.cln * bts2rd,         
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
 2018ae8:	80 a2 20 00 	cmp  %o0, 0                                    
 2018aec:	02 bf ff ee 	be  2018aa4 <msdos_find_name_in_fat_file+0x784><== ALWAYS TAKEN
 2018af0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
                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,
 2018af4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2018af8:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
             * This is a long file name and we need to write          
             * a long file name entry. See if this is the             
             * first entry written and if so remember the             
             * the location of the long file name.                    
             */                                                       
            if (lfn_start.cln == FAT_FILE_SHORT_NAME)                 
 2018afc:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 2018b00:	80 a0 7f ff 	cmp  %g1, -1                                   
 2018b04:	32 80 00 05 	bne,a   2018b18 <msdos_find_name_in_fat_file+0x7f8>
 2018b08:	d8 3f bf c0 	std  %o4, [ %fp + -64 ]                        
            {                                                         
              lfn_start.cln = empty_space_offset;                     
 2018b0c:	ec 27 bf f8 	st  %l6, [ %fp + -8 ]                          
              lfn_start.ofs = dir_entry;                              
 2018b10:	f6 27 bf fc 	st  %i3, [ %fp + -4 ]                          
            }                                                         
                                                                      
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
 2018b14:	d8 3f bf c0 	std  %o4, [ %fp + -64 ]                        
 2018b18:	94 10 20 20 	mov  0x20, %o2                                 
 2018b1c:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         
 2018b20:	d6 27 bf c8 	st  %o3, [ %fp + -56 ]                         
 2018b24:	90 10 00 15 	mov  %l5, %o0                                  
 2018b28:	40 00 0d 9d 	call  201c19c <memset>                         
 2018b2c:	92 10 20 00 	clr  %o1                                       
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
 2018b30:	f8 2d 60 0d 	stb  %i4, [ %l5 + 0xd ]                        
 *     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(                                      
 2018b34:	d6 07 bf c8 	ld  [ %fp + -56 ], %o3                         
 2018b38:	da 07 bf c4 	ld  [ %fp + -60 ], %o5                         
            *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++)             
 2018b3c:	d8 07 bf c0 	ld  [ %fp + -64 ], %o4                         
 2018b40:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
                                                                      
            *MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;            
                                                                      
            p = entry + 1;                                            
 2018b44:	82 05 60 01 	add  %l5, 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(                                      
 2018b48:	9e 02 c0 0d 	add  %o3, %o5, %o7                             
        {                                                             
            char*       entry = (char*) fs_info->cl_buf + dir_entry;  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
 2018b4c:	94 10 20 00 	clr  %o2                                       
            *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++)             
 2018b50:	b0 10 20 00 	clr  %i0                                       
            {                                                         
                if (*n != 0)                                          
 2018b54:	d0 4b c0 00 	ldsb  [ %o7 ], %o0                             
 2018b58:	80 a2 20 00 	cmp  %o0, 0                                    
 2018b5c:	02 80 00 05 	be  2018b70 <msdos_find_name_in_fat_file+0x850>
 2018b60:	d2 0b c0 00 	ldub  [ %o7 ], %o1                             
                {                                                     
                    *p = *n;                                          
 2018b64:	d2 28 40 00 	stb  %o1, [ %g1 ]                              
                    n++;                                              
 2018b68:	10 80 00 05 	b  2018b7c <msdos_find_name_in_fat_file+0x85c> 
 2018b6c:	9e 03 e0 01 	inc  %o7                                       
                }                                                     
                else                                                  
                {                                                     
                    p [0] = fill;                                     
 2018b70:	d4 28 40 00 	stb  %o2, [ %g1 ]                              
                    p [1] = fill;                                     
 2018b74:	d4 28 60 01 	stb  %o2, [ %g1 + 1 ]                          
                    fill = 0xff;                                      
 2018b78:	94 10 3f ff 	mov  -1, %o2                                   
                }                                                     
                                                                      
                switch (i)                                            
 2018b7c:	80 a6 20 04 	cmp  %i0, 4                                    
 2018b80:	02 80 00 06 	be  2018b98 <msdos_find_name_in_fat_file+0x878>
 2018b84:	80 a6 20 0a 	cmp  %i0, 0xa                                  
 2018b88:	32 80 00 08 	bne,a   2018ba8 <msdos_find_name_in_fat_file+0x888>
 2018b8c:	82 00 60 02 	add  %g1, 2, %g1                               
                {                                                     
                    case 4:                                           
                        p += 5;                                       
                        break;                                        
                    case 10:                                          
                        p += 4;                                       
 2018b90:	10 80 00 04 	b  2018ba0 <msdos_find_name_in_fat_file+0x880> 
 2018b94:	82 00 60 04 	add  %g1, 4, %g1                               
                                                                      
                switch (i)                                            
                {                                                     
                    case 4:                                           
                        p += 5;                                       
                        break;                                        
 2018b98:	10 80 00 04 	b  2018ba8 <msdos_find_name_in_fat_file+0x888> 
 2018b9c:	82 00 60 05 	add  %g1, 5, %g1                               
                    case 10:                                          
                        p += 4;                                       
                        break;                                        
 2018ba0:	10 80 00 03 	b  2018bac <msdos_find_name_in_fat_file+0x88c> 
 2018ba4:	b0 06 20 01 	inc  %i0                                       
            *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++)             
 2018ba8:	b0 06 20 01 	inc  %i0                                       
 2018bac:	80 a6 20 0d 	cmp  %i0, 0xd                                  
 2018bb0:	32 bf ff ea 	bne,a   2018b58 <msdos_find_name_in_fat_file+0x838>
 2018bb4:	d0 4b c0 00 	ldsb  [ %o7 ], %o0                             
 *     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(                                      
 2018bb8:	c6 07 bf ec 	ld  [ %fp + -20 ], %g3                         
                        break;                                        
                }                                                     
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
 2018bbc:	80 a0 a0 01 	cmp  %g2, 1                                    
 2018bc0:	02 80 00 04 	be  2018bd0 <msdos_find_name_in_fat_file+0x8b0>
 2018bc4:	82 20 c0 02 	sub  %g3, %g2, %g1                             
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
 2018bc8:	10 80 00 04 	b  2018bd8 <msdos_find_name_in_fat_file+0x8b8> 
 2018bcc:	c2 2b 00 1b 	stb  %g1, [ %o4 + %i3 ]                        
 2018bd0:	82 10 60 40 	or  %g1, 0x40, %g1                             
 2018bd4:	c2 2b 00 1b 	stb  %g1, [ %o4 + %i3 ]                        
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
 2018bd8:	c2 0d 60 0b 	ldub  [ %l5 + 0xb ], %g1                       
 2018bdc:	84 00 a0 01 	inc  %g2                                       
 2018be0:	82 10 60 0f 	or  %g1, 0xf, %g1                              
 2018be4:	9a 03 7f f3 	add  %o5, -13, %o5                             
 2018be8:	c2 2d 60 0b 	stb  %g1, [ %l5 + 0xb ]                        
 *     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(                                      
 2018bec:	b6 06 80 17 	add  %i2, %l7, %i3                             
                                                                      
#if MSDOS_FIND_PRINT                                                  
        printf ("MSFS:[10] eso:%li\n", empty_space_offset);           
#endif                                                                
                                                                      
        for (dir_entry = empty_space_entry;                           
 2018bf0:	80 a6 c0 11 	cmp  %i3, %l1                                  
 2018bf4:	0a bf ff 98 	bcs  2018a54 <msdos_find_name_in_fat_file+0x734><== ALWAYS TAKEN
 2018bf8:	b0 00 bf ff 	add  %g2, -1, %i0                              
            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,                   
 2018bfc:	d8 04 20 a0 	ld  [ %l0 + 0xa0 ], %o4                        <== NOT EXECUTED
 2018c00:	90 10 00 10 	mov  %l0, %o0                                  
 2018c04:	92 10 00 19 	mov  %i1, %o1                                  
 2018c08:	94 07 40 17 	add  %i5, %l7, %o2                             
 2018c0c:	96 10 00 1a 	mov  %i2, %o3                                  
 2018c10:	7f ff e7 6b 	call  20129bc <fat_file_write>                 
 2018c14:	98 03 00 17 	add  %o4, %l7, %o4                             
                             (empty_space_offset * bts2rd) + empty_space_entry,
                             length, fs_info->cl_buf + empty_space_entry);
        if (ret == -1)                                                
 2018c18:	80 a2 3f ff 	cmp  %o0, -1                                   
 2018c1c:	02 80 00 14 	be  2018c6c <msdos_find_name_in_fat_file+0x94c><== NEVER TAKEN
 2018c20:	80 a2 00 1a 	cmp  %o0, %i2                                  
            return ret;                                               
        else if (ret != length)                                       
 2018c24:	02 80 00 08 	be  2018c44 <msdos_find_name_in_fat_file+0x924><== ALWAYS TAKEN
 2018c28:	ba 07 40 11 	add  %i5, %l1, %i5                             
            rtems_set_errno_and_return_minus_one(EIO);                
 2018c2c:	40 00 0a 60 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2018c30:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2018c34:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 2018c38:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2018c3c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2018c40:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        empty_space_offset++;                                         
 2018c44:	ac 05 a0 01 	inc  %l6                                       
        empty_space_entry = 0;                                        
 2018c48:	ae 10 20 00 	clr  %l7                                       
        read_cluster = true;                                          
 2018c4c:	b4 10 20 01 	mov  1, %i2                                    
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
 2018c50:	80 a4 c0 18 	cmp  %l3, %i0                                  
 2018c54:	16 bf ff 47 	bge  2018970 <msdos_find_name_in_fat_file+0x650>
 2018c58:	80 8e a0 ff 	btst  0xff, %i2                                
        empty_space_offset++;                                         
        empty_space_entry = 0;                                        
        read_cluster = true;                                          
    }                                                                 
                                                                      
    return 0;                                                         
 2018c5c:	81 c7 e0 08 	ret                                            
 2018c60:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
                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,
 2018c64:	81 c7 e0 08 	ret                                            
 2018c68:	91 e8 00 08 	restore  %g0, %o0, %o0                         
        }                                                             
                                                                      
        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)                                                
 2018c6c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2018c70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2018c74:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                     * short and they match then we have the entry. We will not
                     * match a long file name against a short file name because
                     * a long file name that generates a matching short file
                     * name is not a long file name.                  
                     */                                               
                    if (lfn_matched ||                                
 2018c78:	80 a0 60 00 	cmp  %g1, 0                                    
 2018c7c:	02 bf fe c8 	be  201879c <msdos_find_name_in_fat_file+0x47c>
 2018c80:	82 10 3f ff 	mov  -1, %g1                                   
                        ((name_type == MSDOS_NAME_SHORT) &&           
 2018c84:	10 bf fe 9c 	b  20186f4 <msdos_find_name_in_fat_file+0x3d4> 
 2018c88:	de 07 bf f8 	ld  [ %fp + -8 ], %o7                          
                                                                      

02018c8c <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 ) {
 2018c8c:	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) &&                                 
 2018c90:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 2018c94:	80 a0 60 01 	cmp  %g1, 1                                    
 2018c98:	12 80 00 0f 	bne  2018cd4 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
 2018c9c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
 2018ca0:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        <== NOT EXECUTED
 2018ca4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2018ca8:	32 80 00 07 	bne,a   2018cc4 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
 2018cac:	f0 17 60 06 	lduh  [ %i5 + 6 ], %i0                         <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
 2018cb0:	c2 0f 60 0e 	ldub  [ %i5 + 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) &&                                 
 2018cb4:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
 2018cb8:	22 80 00 03 	be,a   2018cc4 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
 2018cbc:	f0 17 60 06 	lduh  [ %i5 + 6 ], %i0                         <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
 2018cc0:	f0 06 60 18 	ld  [ %i1 + 0x18 ], %i0                        <== NOT EXECUTED
            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)          
 2018cc4:	27 00 00 3f 	sethi  %hi(0xfc00), %l3                        
                                                                      
        assert(ret == bts2rd);                                        
                                                                      
        for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
 2018cc8:	a2 10 20 00 	clr  %l1                                       
            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)          
 2018ccc:	10 80 00 44 	b  2018ddc <msdos_find_node_by_cluster_num_in_fat_file+0x150>
 2018cd0:	a6 14 e3 ff 	or  %l3, 0x3ff, %l3                            
                                                                      
    if (FAT_FD_OF_ROOT_DIR(fat_fd) &&                                 
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
 2018cd4:	10 bf ff fc 	b  2018cc4 <msdos_find_node_by_cluster_num_in_fat_file+0x38>
 2018cd8:	f0 17 60 06 	lduh  [ %i5 + 6 ], %i0                         
                                                                      
    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 )                
 2018cdc:	14 80 00 08 	bg  2018cfc <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
 2018ce0:	80 a2 00 18 	cmp  %o0, %i0                                  
            rtems_set_errno_and_return_minus_one( EIO );              
 2018ce4:	40 00 0a 32 	call  201b5ac <__errno>                        <== NOT EXECUTED
 2018ce8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2018cec:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 2018cf0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2018cf4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2018cf8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        assert(ret == bts2rd);                                        
 2018cfc:	22 80 00 0a 	be,a   2018d24 <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
 2018d00:	e0 07 60 a0 	ld  [ %i5 + 0xa0 ], %l0                        
 2018d04:	11 00 80 af 	sethi  %hi(0x202bc00), %o0                     <== NOT EXECUTED
 2018d08:	15 00 80 af 	sethi  %hi(0x202bc00), %o2                     <== NOT EXECUTED
 2018d0c:	17 00 80 af 	sethi  %hi(0x202bc00), %o3                     <== NOT EXECUTED
 2018d10:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
 2018d14:	92 10 26 4e 	mov  0x64e, %o1                                <== NOT EXECUTED
 2018d18:	94 12 a1 18 	or  %o2, 0x118, %o2                            <== NOT EXECUTED
 2018d1c:	7f ff ee 80 	call  201471c <__assert_func>                  <== NOT EXECUTED
 2018d20:	96 12 e0 c8 	or  %o3, 0xc8, %o3                             <== NOT EXECUTED
                                                                      
        for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
 2018d24:	a4 10 20 00 	clr  %l2                                       
                                                                      
            /* if this and all rest entries are empty - return not-found */
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
 2018d28:	c2 0c 00 00 	ldub  [ %l0 ], %g1                             
 2018d2c:	80 a0 60 00 	cmp  %g1, 0                                    
 2018d30:	02 80 00 34 	be  2018e00 <msdos_find_node_by_cluster_num_in_fat_file+0x174><== NEVER TAKEN
 2018d34:	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)) ==                     
 2018d38:	22 80 00 25 	be,a   2018dcc <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
 2018d3c:	a4 04 a0 20 	add  %l2, 0x20, %l2                            <== NOT EXECUTED
                MSDOS_THIS_DIR_ENTRY_EMPTY)                           
                continue;                                             
                                                                      
            /* if get a non-empty entry - compare clusters num */     
            if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)          
 2018d40:	c4 14 20 14 	lduh  [ %l0 + 0x14 ], %g2                      
 2018d44:	c2 14 20 1a 	lduh  [ %l0 + 0x1a ], %g1                      
 2018d48:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2018d4c:	87 30 a0 18 	srl  %g2, 0x18, %g3                            
 2018d50:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2018d54:	85 30 a0 08 	srl  %g2, 8, %g2                               
 2018d58:	84 08 80 13 	and  %g2, %l3, %g2                             
 2018d5c:	84 10 c0 02 	or  %g3, %g2, %g2                              
 2018d60:	87 30 60 18 	srl  %g1, 0x18, %g3                            
 2018d64:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2018d68:	83 30 60 08 	srl  %g1, 8, %g1                               
 2018d6c:	82 08 40 13 	and  %g1, %l3, %g1                             
 2018d70:	82 10 c0 01 	or  %g3, %g1, %g1                              
 2018d74:	82 10 80 01 	or  %g2, %g1, %g1                              
 2018d78:	80 a0 40 1a 	cmp  %g1, %i2                                  
 2018d7c:	32 80 00 14 	bne,a   2018dcc <msdos_find_node_by_cluster_num_in_fat_file+0x140>
 2018d80:	a4 04 a0 20 	add  %l2, 0x20, %l2                            
            {                                                         
                /* on success fill aux structure and copy all 32 bytes */
                rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
 2018d84:	90 10 00 1d 	mov  %i5, %o0                                  
 2018d88:	92 10 00 19 	mov  %i1, %o1                                  
 2018d8c:	94 10 20 01 	mov  1, %o2                                    
 2018d90:	96 10 00 11 	mov  %l1, %o3                                  
 2018d94:	7f ff e6 40 	call  2012694 <fat_file_ioctl>                 
 2018d98:	98 10 00 1b 	mov  %i3, %o4                                  
                                    &dir_pos->sname.cln);             
                if (rc != RC_OK)                                      
 2018d9c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2018da0:	12 bf ff d5 	bne  2018cf4 <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
 2018da4:	82 10 3f ff 	mov  -1, %g1                                   
                    return rc;                                        
                                                                      
                dir_pos->sname.ofs = i;                               
 2018da8:	e4 26 e0 04 	st  %l2, [ %i3 + 4 ]                           
                dir_pos->lname.cln = FAT_FILE_SHORT_NAME;             
 2018dac:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
                dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;             
 2018db0:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
                                                                      
                memcpy(dir_entry, entry,                              
 2018db4:	90 10 00 1c 	mov  %i4, %o0                                  
 2018db8:	92 10 00 10 	mov  %l0, %o1                                  
 2018dbc:	40 00 0c bb 	call  201c0a8 <memcpy>                         
 2018dc0:	94 10 20 20 	mov  0x20, %o2                                 
                       MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);            
                return RC_OK;                                         
 2018dc4:	81 c7 e0 08 	ret                                            
 2018dc8:	81 e8 00 00 	restore                                        
        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)
 2018dcc:	80 a4 80 18 	cmp  %l2, %i0                                  
 2018dd0:	0a bf ff d6 	bcs  2018d28 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
 2018dd4:	a0 04 20 20 	add  %l0, 0x20, %l0                            
 2018dd8:	a2 04 40 18 	add  %l1, %i0, %l1                             <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
        bts2rd = fat_fd->fat_file_size;                               
    else                                                              
        bts2rd = fs_info->fat.vol.bpc;                                
                                                                      
    while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
 2018ddc:	d8 07 60 a0 	ld  [ %i5 + 0xa0 ], %o4                        
 2018de0:	90 10 00 1d 	mov  %i5, %o0                                  
 2018de4:	92 10 00 19 	mov  %i1, %o1                                  
 2018de8:	94 10 00 11 	mov  %l1, %o2                                  
 2018dec:	7f ff e5 4a 	call  2012314 <fat_file_read>                  
 2018df0:	96 10 00 18 	mov  %i0, %o3                                  
 2018df4:	80 a2 20 00 	cmp  %o0, 0                                    
 2018df8:	12 bf ff b9 	bne  2018cdc <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
 2018dfc:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
            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;                      
 2018e00:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        <== NOT EXECUTED
 2018e04:	b0 16 21 01 	or  %i0, 0x101, %i0	! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
            }                                                         
        }                                                             
        j++;                                                          
    }                                                                 
    return MSDOS_NAME_NOT_FOUND_ERR;                                  
}                                                                     
 2018e08:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2018e0c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200d864 <msdos_format>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
 200d864:	9d e3 bc d0 	save  %sp, -816, %sp                           
  msdos_format_param_t fmt_params;                                    
                                                                      
  /*                                                                  
   * open device for writing                                          
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
 200d868:	92 10 20 02 	mov  2, %o1                                    
 200d86c:	90 10 00 19 	mov  %i1, %o0                                  
 200d870:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200d874:	7f ff ff 60 	call  200d5f4 <msdos_format_printf>            
 200d878:	94 12 a1 b0 	or  %o2, 0x1b0, %o2	! 202b5b0 <_CPU_Trap_slot_template+0x68>
  fd = open(devname, O_RDWR);                                         
 200d87c:	92 10 20 02 	mov  2, %o1                                    
 200d880:	7f ff e2 2a 	call  2006128 <open>                           
 200d884:	90 10 00 18 	mov  %i0, %o0                                  
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  char                 tmp_sec[FAT_TOTAL_MBR_SIZE];                   
  struct stat          stat_buf;                                      
  int                  ret_val   = 0;                                 
 200d888:	82 38 00 08 	xnor  %g0, %o0, %g1                            
 200d88c:	80 a0 00 01 	cmp  %g0, %g1                                  
                                                                      
  /*                                                                  
   * open device for writing                                          
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
  fd = open(devname, O_RDWR);                                         
 200d890:	b8 10 00 08 	mov  %o0, %i4                                  
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  char                 tmp_sec[FAT_TOTAL_MBR_SIZE];                   
  struct stat          stat_buf;                                      
  int                  ret_val   = 0;                                 
 200d894:	b6 40 3f ff 	addx  %g0, -1, %i3                             
  }                                                                   
                                                                      
  /*                                                                  
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
 200d898:	90 10 00 19 	mov  %i1, %o0                                  
 200d89c:	92 10 20 02 	mov  2, %o1                                    
 200d8a0:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200d8a4:	96 10 00 18 	mov  %i0, %o3                                  
 200d8a8:	7f ff ff 53 	call  200d5f4 <msdos_format_printf>            
 200d8ac:	94 12 a1 c0 	or  %o2, 0x1c0, %o2                            
                       "stat check: %s\n", devname);                  
  if (ret_val == 0) {                                                 
 200d8b0:	80 a6 e0 00 	cmp  %i3, 0                                    
 200d8b4:	12 80 00 06 	bne  200d8cc <msdos_format+0x68>               <== NEVER TAKEN
 200d8b8:	ba 10 3f ff 	mov  -1, %i5                                   
    ret_val = fstat(fd, &stat_buf);                                   
 200d8bc:	90 10 00 1c 	mov  %i4, %o0                                  
 200d8c0:	7f ff de cf 	call  20053fc <fstat>                          
 200d8c4:	92 07 bd 60 	add  %fp, -672, %o1                            
 200d8c8:	ba 10 00 08 	mov  %o0, %i5                                  
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
 200d8cc:	90 10 00 19 	mov  %i1, %o0                                  
 200d8d0:	92 10 20 01 	mov  1, %o1                                    
 200d8d4:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200d8d8:	96 10 00 18 	mov  %i0, %o3                                  
 200d8dc:	7f ff ff 46 	call  200d5f4 <msdos_format_printf>            
 200d8e0:	94 12 a1 d0 	or  %o2, 0x1d0, %o2                            
                       "formating: %s\n", devname);                   
  /* rtems feature: no block devices, all are character devices */    
  if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {               
 200d8e4:	80 a7 60 00 	cmp  %i5, 0                                    
 200d8e8:	12 80 02 0d 	bne  200e11c <msdos_format+0x8b8>              <== NEVER TAKEN
 200d8ec:	80 a0 00 19 	cmp  %g0, %i1                                  
 200d8f0:	c4 07 bd 6c 	ld  [ %fp + -660 ], %g2                        
 200d8f4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 200d8f8:	84 08 80 01 	and  %g2, %g1, %g2                             
 200d8fc:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
 200d900:	80 a0 80 01 	cmp  %g2, %g1                                  
 200d904:	02 80 03 7d 	be  200e6f8 <msdos_format+0xe94>               <== ALWAYS TAKEN
 200d908:	92 10 20 00 	clr  %o1                                       
    errno = ENOTTY;                                                   
 200d90c:	40 00 37 28 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200d910:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
 200d914:	82 10 20 19 	mov  0x19, %g1                                 <== NOT EXECUTED
 200d918:	10 80 02 00 	b  200e118 <msdos_format+0x8b4>                <== NOT EXECUTED
 200d91c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== 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);                 
 200d920:	92 16 e2 05 	or  %i3, 0x205, %o1                            
 200d924:	40 00 1c 3d 	call  2014a18 <ioctl>                          
 200d928:	94 07 bd b0 	add  %fp, -592, %o2                            
    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) {                                                 
 200d92c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200d930:	12 80 01 67 	bne  200decc <msdos_format+0x668>              <== NEVER TAKEN
 200d934:	f0 07 bd ac 	ld  [ %fp + -596 ], %i0                        
    total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
 200d938:	fa 07 bd b0 	ld  [ %fp + -592 ], %i5                        
 200d93c:	92 10 00 18 	mov  %i0, %o1                                  
 200d940:	7f ff d3 44 	call  2002650 <.umul>                          
 200d944:	90 10 00 1d 	mov  %i5, %o0                                  
 200d948:	b4 10 20 00 	clr  %i2                                       
 200d94c:	b6 10 00 08 	mov  %o0, %i3                                  
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
 200d950:	d0 23 a0 5c 	st  %o0, [ %sp + 0x5c ]                        
 200d954:	f4 3f bd 58 	std  %i2, [ %fp + -680 ]                       
 200d958:	9a 10 20 00 	clr  %o5                                       
 200d95c:	90 10 00 19 	mov  %i1, %o0                                  
 200d960:	92 10 20 02 	mov  2, %o1                                    
 200d964:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200d968:	96 10 00 18 	mov  %i0, %o3                                  
 200d96c:	94 12 a1 e0 	or  %o2, 0x1e0, %o2                            
 200d970:	7f ff ff 21 	call  200d5f4 <msdos_format_printf>            
 200d974:	98 10 00 1d 	mov  %i5, %o4                                  
                                                                      
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
 200d978:	80 a6 60 00 	cmp  %i1, 0                                    
 200d97c:	02 80 00 0a 	be  200d9a4 <msdos_format+0x140>               
 200d980:	82 10 20 02 	mov  2, %g1                                    
	(rqdata->fat_num == 0)) {                                            
 200d984:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
                                                                      
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
 200d988:	80 a0 60 00 	cmp  %g1, 0                                    
 200d98c:	12 80 00 04 	bne  200d99c <msdos_format+0x138>              
 200d990:	80 a0 60 06 	cmp  %g1, 6                                    
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
 200d994:	10 80 00 04 	b  200d9a4 <msdos_format+0x140>                
 200d998:	82 10 20 02 	mov  2, %g1                                    
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
 200d99c:	18 80 00 04 	bgu  200d9ac <msdos_format+0x148>              
 200d9a0:	01 00 00 00 	nop                                            
      fmt_params->fat_num = rqdata->fat_num;                          
 200d9a4:	10 80 03 62 	b  200e72c <msdos_format+0xec8>                
 200d9a8:	c2 2f bd dc 	stb  %g1, [ %fp + -548 ]                       
    }                                                                 
    else {                                                            
      errno = EINVAL;                                                 
 200d9ac:	40 00 37 00 	call  201b5ac <__errno>                        
 200d9b0:	ba 10 3f ff 	mov  -1, %i5                                   
 200d9b4:	82 10 20 16 	mov  0x16, %g1                                 
 200d9b8:	10 80 01 45 	b  200decc <msdos_format+0x668>                
 200d9bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
     * 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) {         
 200d9c0:	84 90 60 00 	orcc  %g1, 0, %g2                              
 200d9c4:	12 80 00 05 	bne  200d9d8 <msdos_format+0x174>              
 200d9c8:	c6 07 bd b0 	ld  [ %fp + -592 ], %g3                        
     * 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;                               
 200d9cc:	84 10 20 20 	mov  0x20, %g2                                 
    /*                                                                
     * 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;                                
 200d9d0:	82 10 20 08 	mov  8, %g1                                    
    if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {         
      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) {
 200d9d4:	c6 07 bd b0 	ld  [ %fp + -592 ], %g3                        
 200d9d8:	89 28 60 02 	sll  %g1, 2, %g4                               
 200d9dc:	bb 28 60 0a 	sll  %g1, 0xa, %i5                             
 200d9e0:	88 27 40 04 	sub  %i5, %g4, %g4                             
 200d9e4:	88 01 00 01 	add  %g4, %g1, %g4                             
 200d9e8:	89 29 20 02 	sll  %g4, 2, %g4                               
 200d9ec:	82 01 00 01 	add  %g4, %g1, %g1                             
 200d9f0:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200d9f4:	3a 80 00 04 	bcc,a   200da04 <msdos_format+0x1a0>           
 200d9f8:	83 28 a0 02 	sll  %g2, 2, %g1                               
      fmt_params->fattype = FAT_FAT12;                                
 200d9fc:	10 80 00 0b 	b  200da28 <msdos_format+0x1c4>                
 200da00:	82 10 20 01 	mov  1, %g1                                    
      /* 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) {
 200da04:	89 28 a0 0e 	sll  %g2, 0xe, %g4                             
 200da08:	82 21 00 01 	sub  %g4, %g1, %g1                             
 200da0c:	82 00 40 02 	add  %g1, %g2, %g1                             
 200da10:	83 28 60 02 	sll  %g1, 2, %g1                               
 200da14:	84 00 40 02 	add  %g1, %g2, %g2                             
 200da18:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200da1c:	1a 80 00 06 	bcc  200da34 <msdos_format+0x1d0>              
 200da20:	1b 10 00 00 	sethi  %hi(0x40000000), %o5                    
      fmt_params->fattype = FAT_FAT16;                                
 200da24:	82 10 20 02 	mov  2, %g1                                    
 200da28:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
 200da2c:	10 80 00 15 	b  200da80 <msdos_format+0x21c>                
 200da30:	82 10 20 02 	mov  2, %g1                                    
    }                                                                 
    else {                                                            
      #define ONE_GB (1024L * 1024L * 1024L)                          
      uint32_t gigs = (total_size + ONE_GB) / ONE_GB;                 
 200da34:	86 86 c0 0d 	addcc  %i3, %o5, %g3                           
 200da38:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
 200da3c:	98 10 20 00 	clr  %o4                                       
 200da40:	84 46 80 0c 	addx  %i2, %o4, %g2                            
 200da44:	85 28 a0 02 	sll  %g2, 2, %g2                               
 200da48:	84 10 80 01 	or  %g2, %g1, %g2                              
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
 200da4c:	82 10 20 04 	mov  4, %g1                                    
      /* scale with the size of disk... */                            
      for (b = 31; b > 0; b--)                                        
        if ((gigs & (1 << b)) != 0)                                   
 200da50:	86 10 20 01 	mov  1, %g3                                    
    }                                                                 
    else {                                                            
      #define ONE_GB (1024L * 1024L * 1024L)                          
      uint32_t gigs = (total_size + ONE_GB) / ONE_GB;                 
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
 200da54:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       
      /* scale with the size of disk... */                            
      for (b = 31; b > 0; b--)                                        
 200da58:	82 10 20 1f 	mov  0x1f, %g1                                 
        if ((gigs & (1 << b)) != 0)                                   
 200da5c:	89 28 c0 01 	sll  %g3, %g1, %g4                             
 200da60:	80 89 00 02 	btst  %g4, %g2                                 
 200da64:	32 80 00 06 	bne,a   200da7c <msdos_format+0x218>           
 200da68:	84 10 20 01 	mov  1, %g2                                    
      #define ONE_GB (1024L * 1024L * 1024L)                          
      uint32_t gigs = (total_size + ONE_GB) / ONE_GB;                 
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
      /* scale with the size of disk... */                            
      for (b = 31; b > 0; b--)                                        
 200da6c:	82 80 7f ff 	addcc  %g1, -1, %g1                            
 200da70:	12 bf ff fc 	bne  200da60 <msdos_format+0x1fc>              
 200da74:	89 28 c0 01 	sll  %g3, %g1, %g4                             
        if ((gigs & (1 << b)) != 0)                                   
          break;                                                      
      fmt_params->sectors_per_cluster = 1 << b;                       
 200da78:	84 10 20 01 	mov  1, %g2                                    
 200da7c:	83 28 80 01 	sll  %g2, %g1, %g1                             
 200da80:	c2 27 bd b8 	st  %g1, [ %fp + -584 ]                        
    }                                                                 
                                                                      
    ret_val = msdos_set_sectors_per_cluster_from_request( rqdata, fmt_params );
 200da84:	90 10 00 19 	mov  %i1, %o0                                  
 200da88:	7f ff ff 53 	call  200d7d4 <msdos_set_sectors_per_cluster_from_request>
 200da8c:	92 07 bd ac 	add  %fp, -596, %o1                            
    /* 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;                 
 200da90:	98 10 20 00 	clr  %o4                                       
 200da94:	1b 10 00 00 	sethi  %hi(0x40000000), %o5                    
 200da98:	86 86 c0 0d 	addcc  %i3, %o5, %g3                           
 200da9c:	84 46 80 0c 	addx  %i2, %o4, %g2                            
 200daa0:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
 200daa4:	85 28 a0 02 	sll  %g2, 2, %g2                               
 200daa8:	82 10 80 01 	or  %g2, %g1, %g1                              
          && fmt_params->fattype != fat_type                          
          && fmt_params->totl_sector_cnt > 0 ) {                      
      /*                                                              
       * Skip aligning structures or d align them                     
       */                                                             
      if (ret_val == 0 && rqdata != NULL)                             
 200daac:	80 a0 00 19 	cmp  %g0, %i1                                  
    /* 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;                 
 200dab0:	c2 27 bd 40 	st  %g1, [ %fp + -704 ]                        
        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 );
 200dab4:	ba 10 00 08 	mov  %o0, %i5                                  
          && fmt_params->fattype != fat_type                          
          && fmt_params->totl_sector_cnt > 0 ) {                      
      /*                                                              
       * Skip aligning structures or d align them                     
       */                                                             
      if (ret_val == 0 && rqdata != NULL)                             
 200dab8:	82 40 20 00 	addx  %g0, 0, %g1                              
    /* 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;                 
 200dabc:	b4 10 3f ff 	mov  -1, %i2                                   
 200dac0:	a8 10 20 00 	clr  %l4                                       
          && fmt_params->fattype != fat_type                          
          && fmt_params->totl_sector_cnt > 0 ) {                      
      /*                                                              
       * Skip aligning structures or d align them                     
       */                                                             
      if (ret_val == 0 && rqdata != NULL)                             
 200dac4:	10 80 00 f8 	b  200dea4 <msdos_format+0x640>                
 200dac8:	c2 27 bd 48 	st  %g1, [ %fp + -696 ]                        
 200dacc:	80 a1 20 00 	cmp  %g4, 0                                    
 200dad0:	02 80 00 05 	be  200dae4 <msdos_format+0x280>               
 200dad4:	d6 07 bd b8 	ld  [ %fp + -584 ], %o3                        
        fmt_params->skip_alignment = rqdata->skip_alignment;          
 200dad8:	c2 0e 60 16 	ldub  [ %i1 + 0x16 ], %g1                      
 200dadc:	c2 2f bd fc 	stb  %g1, [ %fp + -516 ]                       
                                                                      
      if (ret_val == 0) {                                             
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,     
 200dae0:	d6 07 bd b8 	ld  [ %fp + -584 ], %o3                        
 200dae4:	90 10 00 19 	mov  %i1, %o0                                  
 200dae8:	92 10 20 02 	mov  2, %o1                                    
 200daec:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200daf0:	7f ff fe c1 	call  200d5f4 <msdos_format_printf>            
 200daf4:	94 12 a2 20 	or  %o2, 0x220, %o2	! 202b620 <_CPU_Trap_slot_template+0xd8>
                             "sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
                                                                      
        if (fmt_params->fattype == FAT_FAT32) {                       
 200daf8:	f4 0f bd de 	ldub  [ %fp + -546 ], %i2                      
 200dafc:	82 0e a0 ff 	and  %i2, 0xff, %g1                            
 200db00:	80 a0 60 04 	cmp  %g1, 4                                    
 200db04:	12 80 00 0a 	bne  200db2c <msdos_format+0x2c8>              
 200db08:	82 10 20 01 	mov  1, %g1                                    
          /* recommended: for FAT32, always set reserved sector count to 32 */
          fmt_params->rsvd_sector_cnt = 32;                           
 200db0c:	82 10 20 20 	mov  0x20, %g1                                 
 200db10:	c2 27 bd b4 	st  %g1, [ %fp + -588 ]                        
          /* 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;                               
 200db14:	82 10 20 06 	mov  6, %g1                                    
                                                                      
        if (fmt_params->fattype == FAT_FAT32) {                       
          /* recommended: for FAT32, always set reserved sector count to 32 */
          fmt_params->rsvd_sector_cnt = 32;                           
          /* for FAT32, always set files per root directory 0 */      
          fmt_params->files_per_root_dir = 0;                         
 200db18:	c0 27 bd c4 	clr  [ %fp + -572 ]                            
          /* location of copy of MBR */                               
          fmt_params->mbr_copy_sec = 6;                               
 200db1c:	c2 27 bd d4 	st  %g1, [ %fp + -556 ]                        
          /* location of fsinfo sector */                             
          fmt_params->fsinfo_sec = 1;                                 
 200db20:	82 10 20 01 	mov  1, %g1                                    
 200db24:	10 80 00 1c 	b  200db94 <msdos_format+0x330>                
 200db28:	c2 27 bd d8 	st  %g1, [ %fp + -552 ]                        
                                                                      
        }                                                             
        else {                                                        
          /* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
          fmt_params->rsvd_sector_cnt = 1;                            
 200db2c:	c2 27 bd b4 	st  %g1, [ %fp + -588 ]                        
          /* 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) &&                                     
 200db30:	c2 07 bd 48 	ld  [ %fp + -696 ], %g1                        
 200db34:	80 a0 60 00 	cmp  %g1, 0                                    
 200db38:	02 80 00 08 	be  200db58 <msdos_format+0x2f4>               
 200db3c:	82 0e a0 ff 	and  %i2, 0xff, %g1                            
              (rqdata->files_per_root_dir > 0)) {                     
 200db40:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
          /* 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) &&                                     
 200db44:	80 a0 60 00 	cmp  %g1, 0                                    
 200db48:	22 80 00 04 	be,a   200db58 <msdos_format+0x2f4>            
 200db4c:	82 0e a0 ff 	and  %i2, 0xff, %g1                            
          else {                                                      
            if (fmt_params->fattype == FAT_FAT16) {                   
              fmt_params->files_per_root_dir = 512;                   
            }                                                         
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
 200db50:	10 80 00 07 	b  200db6c <msdos_format+0x308>                
 200db54:	c2 27 bd c4 	st  %g1, [ %fp + -572 ]                        
          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) {                   
 200db58:	80 a0 60 02 	cmp  %g1, 2                                    
 200db5c:	32 80 00 03 	bne,a   200db68 <msdos_format+0x304>           
 200db60:	82 10 20 40 	mov  0x40, %g1                                 
 200db64:	82 10 22 00 	mov  0x200, %g1                                
              fmt_params->files_per_root_dir = 512;                   
            }                                                         
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
 200db68:	c2 27 bd c4 	st  %g1, [ %fp + -572 ]                        
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
                                           (2*fmt_params->bytes_per_sector/
 200db6c:	d2 07 bd ac 	ld  [ %fp + -596 ], %o1                        
            }                                                         
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
 200db70:	f6 07 bd c4 	ld  [ %fp + -572 ], %i3                        
                                           (2*fmt_params->bytes_per_sector/
 200db74:	93 2a 60 01 	sll  %o1, 1, %o1                               
            }                                                         
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
 200db78:	b6 06 ff ff 	add  %i3, -1, %i3                              
                                           (2*fmt_params->bytes_per_sector/
 200db7c:	93 32 60 05 	srl  %o1, 5, %o1                               
            }                                                         
            else {                                                    
              fmt_params->files_per_root_dir = 64;                    
            }                                                         
          }                                                           
          fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
 200db80:	b6 06 c0 09 	add  %i3, %o1, %i3                             
                                           (2*fmt_params->bytes_per_sector/
                                           FAT_DIRENTRY_SIZE-1));     
          fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
 200db84:	40 00 6b f6 	call  2028b5c <.urem>                          
 200db88:	90 10 00 1b 	mov  %i3, %o0                                  
 200db8c:	90 26 c0 08 	sub  %i3, %o0, %o0                             
 200db90:	d0 27 bd c4 	st  %o0, [ %fp + -572 ]                        
                                            /FAT_DIRENTRY_SIZE));     
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
            + fmt_params->bytes_per_sector - 1)                       
 200db94:	f6 07 bd ac 	ld  [ %fp + -596 ], %i3                        
                                            (2*fmt_params->bytes_per_sector
                                            /FAT_DIRENTRY_SIZE));     
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
 200db98:	d0 07 bd c4 	ld  [ %fp + -572 ], %o0                        
            + fmt_params->bytes_per_sector - 1)                       
 200db9c:	88 06 ff ff 	add  %i3, -1, %g4                              
           / fmt_params->bytes_per_sector);                           
 200dba0:	92 10 00 1b 	mov  %i3, %o1                                  
                                            /FAT_DIRENTRY_SIZE));     
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
            + fmt_params->bytes_per_sector - 1)                       
 200dba4:	c8 27 bd 54 	st  %g4, [ %fp + -684 ]                        
                                            (2*fmt_params->bytes_per_sector
                                            /FAT_DIRENTRY_SIZE));     
                                                                      
        }                                                             
        fmt_params->root_dir_sectors =                                
          (((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)      
 200dba8:	91 2a 20 05 	sll  %o0, 5, %o0                               
            + fmt_params->bytes_per_sector - 1)                       
           / fmt_params->bytes_per_sector);                           
 200dbac:	7f ff d2 e3 	call  2002738 <.udiv>                          
 200dbb0:	90 01 00 08 	add  %g4, %o0, %o0                             
      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,
 200dbb4:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        
 200dbb8:	c8 07 bd b4 	ld  [ %fp + -588 ], %g4                        
                                                                      
        }                                                             
        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);                           
 200dbbc:	a4 10 00 08 	mov  %o0, %l2                                  
          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 =                                
 200dbc0:	d0 27 bd c8 	st  %o0, [ %fp + -568 ]                        
      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,
 200dbc4:	b0 0e a0 ff 	and  %i2, 0xff, %i0                            
 200dbc8:	c2 27 bd 44 	st  %g1, [ %fp + -700 ]                        
 200dbcc:	c8 27 bd 50 	st  %g4, [ %fp + -688 ]                        
 200dbd0:	ea 0f bd dc 	ldub  [ %fp + -548 ], %l5                      
 200dbd4:	ec 07 bd b8 	ld  [ %fp + -584 ], %l6                        
 200dbd8:	e6 0f bd fc 	ldub  [ %fp + -516 ], %l3                      
  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) {
 200dbdc:	92 10 00 1b 	mov  %i3, %o1                                  
 200dbe0:	7f ff d2 d6 	call  2002738 <.udiv>                          
 200dbe4:	11 00 00 20 	sethi  %hi(0x8000), %o0                        
 200dbe8:	10 80 00 03 	b  200dbf4 <msdos_format+0x390>                
 200dbec:	80 a2 00 16 	cmp  %o0, %l6                                  
 200dbf0:	80 a2 00 16 	cmp  %o0, %l6                                  <== NOT EXECUTED
 200dbf4:	2a bf ff ff 	bcs,a   200dbf0 <msdos_format+0x38c>           <== NEVER TAKEN
 200dbf8:	ad 35 a0 01 	srl  %l6, 1, %l6                               <== 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);          
 200dbfc:	c2 07 bd 50 	ld  [ %fp + -688 ], %g1                        
                                                                      
    sectors_per_fat = ((fat_capacity                                  
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,    
 200dc00:	aa 0d 60 ff 	and  %l5, 0xff, %l5                            
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200dc04:	82 00 7f ff 	add  %g1, -1, %g1                              
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200dc08:	a6 0c e0 ff 	and  %l3, 0xff, %l3                            
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200dc0c:	c2 27 bd 3c 	st  %g1, [ %fp + -708 ]                        
 200dc10:	ae 04 bf ff 	add  %l2, -1, %l7                              
                                                                      
    sectors_per_fat = ((fat_capacity                                  
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,    
 200dc14:	ea 27 bd 4c 	st  %l5, [ %fp + -692 ]                        
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200dc18:	80 a4 e0 00 	cmp  %l3, 0                                    
 200dc1c:	12 80 00 06 	bne  200dc34 <msdos_format+0x3d0>              
 200dc20:	d0 07 bd 50 	ld  [ %fp + -688 ], %o0                        
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200dc24:	c8 07 bd 3c 	ld  [ %fp + -708 ], %g4                        
 200dc28:	90 20 00 16 	neg  %l6, %o0                                  
 200dc2c:	84 01 00 16 	add  %g4, %l6, %g2                             
 200dc30:	90 0a 00 02 	and  %o0, %g2, %o0                             
     * 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                               
 200dc34:	c2 07 bd 44 	ld  [ %fp + -700 ], %g1                        
      - loc_align_object (rsvd_sector_cnt, sectors_per_cluster, skip_alignment);
    if (fattype == FAT_FAT12) {                                       
 200dc38:	80 a6 20 01 	cmp  %i0, 1                                    
 200dc3c:	12 80 00 10 	bne  200dc7c <msdos_format+0x418>              
 200dc40:	90 20 40 08 	sub  %g1, %o0, %o0                             
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200dc44:	80 a4 e0 00 	cmp  %l3, 0                                    
 200dc48:	12 80 00 05 	bne  200dc5c <msdos_format+0x3f8>              
 200dc4c:	84 10 00 12 	mov  %l2, %g2                                  
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200dc50:	84 05 c0 16 	add  %l7, %l6, %g2                             
 200dc54:	86 20 00 16 	neg  %l6, %g3                                  
 200dc58:	84 08 c0 02 	and  %g3, %g2, %g2                             
    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;     
 200dc5c:	90 22 00 02 	sub  %o0, %g2, %o0                             
 200dc60:	7f ff d2 b6 	call  2002738 <.udiv>                          
 200dc64:	92 10 00 16 	mov  %l6, %o1                                  
 200dc68:	a0 10 00 08 	mov  %o0, %l0                                  
      fat_capacity        = fatdata_cluster_cnt * 3 / 2;              
 200dc6c:	91 2a 20 01 	sll  %o0, 1, %o0                               
 200dc70:	90 02 00 10 	add  %o0, %l0, %o0                             
 200dc74:	10 80 00 14 	b  200dcc4 <msdos_format+0x460>                
 200dc78:	91 32 20 01 	srl  %o0, 1, %o0                               
    }                                                                 
    else if (fattype == FAT_FAT16) {                                  
 200dc7c:	80 a6 20 02 	cmp  %i0, 2                                    
 200dc80:	12 80 00 0d 	bne  200dcb4 <msdos_format+0x450>              
 200dc84:	80 a4 e0 00 	cmp  %l3, 0                                    
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200dc88:	12 80 00 05 	bne  200dc9c <msdos_format+0x438>              
 200dc8c:	84 10 00 12 	mov  %l2, %g2                                  
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200dc90:	84 05 c0 16 	add  %l7, %l6, %g2                             
 200dc94:	86 20 00 16 	neg  %l6, %g3                                  
 200dc98:	84 08 c0 02 	and  %g3, %g2, %g2                             
      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;     
 200dc9c:	90 22 00 02 	sub  %o0, %g2, %o0                             
 200dca0:	7f ff d2 a6 	call  2002738 <.udiv>                          
 200dca4:	92 10 00 16 	mov  %l6, %o1                                  
 200dca8:	a0 10 00 08 	mov  %o0, %l0                                  
      fat_capacity        = fatdata_cluster_cnt * 2;                  
 200dcac:	10 80 00 06 	b  200dcc4 <msdos_format+0x460>                
 200dcb0:	91 2a 20 01 	sll  %o0, 1, %o0                               
    }                                                                 
    else { /* FAT32 */                                                
      fatdata_cluster_cnt = fatdata_sect_cnt/sectors_per_cluster;     
 200dcb4:	7f ff d2 a1 	call  2002738 <.udiv>                          
 200dcb8:	92 10 00 16 	mov  %l6, %o1                                  
 200dcbc:	a0 10 00 08 	mov  %o0, %l0                                  
      fat_capacity        = fatdata_cluster_cnt * 4;                  
 200dcc0:	91 2a 20 02 	sll  %o0, 2, %o0                               
    }                                                                 
                                                                      
    sectors_per_fat = ((fat_capacity                                  
 200dcc4:	c8 07 bd 54 	ld  [ %fp + -684 ], %g4                        
 200dcc8:	92 10 00 1b 	mov  %i3, %o1                                  
 200dccc:	7f ff d2 9b 	call  2002738 <.udiv>                          
 200dcd0:	90 02 00 04 	add  %o0, %g4, %o0                             
			+ (bytes_per_sector - 1))                                          
		       / bytes_per_sector);                                         
                                                                      
    fat_sectors_cnt = loc_align_object (sectors_per_fat * fat_num,    
 200dcd4:	7f ff d2 5f 	call  2002650 <.umul>                          
 200dcd8:	d2 07 bd 4c 	ld  [ %fp + -692 ], %o1                        
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200dcdc:	80 a4 e0 00 	cmp  %l3, 0                                    
 200dce0:	12 80 00 06 	bne  200dcf8 <msdos_format+0x494>              
 200dce4:	a2 10 00 08 	mov  %o0, %l1                                  
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200dce8:	84 05 bf ff 	add  %l6, -1, %g2                              
 200dcec:	a2 00 80 08 	add  %g2, %o0, %l1                             
 200dcf0:	84 20 00 16 	neg  %l6, %g2                                  
 200dcf4:	a2 0c 40 02 	and  %l1, %g2, %l1                             
                                        sectors_per_cluster,          
                                        skip_alignment);              
                                                                      
    *data_cluster_cnt = (fatdata_cluster_cnt -                        
			((fat_sectors_cnt                                                  
			  + (sectors_per_cluster - 1))                                     
 200dcf8:	90 05 bf ff 	add  %l6, -1, %o0                              
			 / sectors_per_cluster));                                          
 200dcfc:	92 10 00 16 	mov  %l6, %o1                                  
 200dd00:	7f ff d2 8e 	call  2002738 <.udiv>                          
 200dd04:	90 02 00 11 	add  %o0, %l1, %o0                             
    /*                                                                
     * data cluster count too big? Then make clusters bigger          
     */                                                               
    if (((fattype == FAT_FAT12) && (*data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
 200dd08:	80 a6 20 01 	cmp  %i0, 1                                    
 200dd0c:	12 80 00 07 	bne  200dd28 <msdos_format+0x4c4>              
 200dd10:	a0 24 00 08 	sub  %l0, %o0, %l0                             
 200dd14:	80 a4 2f f5 	cmp  %l0, 0xff5                                
 200dd18:	08 80 00 10 	bleu  200dd58 <msdos_format+0x4f4>             
 200dd1c:	aa 10 20 01 	mov  1, %l5                                    
        ((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
      sectors_per_cluster *= 2;                                       
 200dd20:	10 80 00 0b 	b  200dd4c <msdos_format+0x4e8>                
 200dd24:	ad 2d a0 01 	sll  %l6, 1, %l6                               
			  + (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)) ||
 200dd28:	80 a6 20 02 	cmp  %i0, 2                                    
 200dd2c:	12 80 00 11 	bne  200dd70 <msdos_format+0x50c>              
 200dd30:	aa 10 20 01 	mov  1, %l5                                    
        ((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
 200dd34:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 200dd38:	82 10 63 f5 	or  %g1, 0x3f5, %g1	! fff5 <PROM_START+0xfff5> 
 200dd3c:	80 a4 00 01 	cmp  %l0, %g1                                  
 200dd40:	08 80 00 0d 	bleu  200dd74 <msdos_format+0x510>             
 200dd44:	90 10 00 16 	mov  %l6, %o0                                  
      sectors_per_cluster *= 2;                                       
 200dd48:	ad 2d a0 01 	sll  %l6, 1, %l6                               
      finished = true;                                                
    }                                                                 
    /*                                                                
     * when maximum cluster size is exceeded, we have invalid data, abort...
     */                                                               
    if (fattype == FAT_FAT12) {                                       
 200dd4c:	80 a6 20 01 	cmp  %i0, 1                                    
 200dd50:	12 80 00 08 	bne  200dd70 <msdos_format+0x50c>              
 200dd54:	aa 10 20 00 	clr  %l5                                       
      if (MS_BYTES_PER_CLUSTER_LIMIT_FAT12 < (sectors_per_cluster * bytes_per_sector)) {
 200dd58:	90 10 00 16 	mov  %l6, %o0                                  
 200dd5c:	7f ff d2 3d 	call  2002650 <.umul>                          
 200dd60:	92 10 00 1b 	mov  %i3, %o1                                  
 200dd64:	09 00 00 04 	sethi  %hi(0x1000), %g4                        
 200dd68:	10 80 00 07 	b  200dd84 <msdos_format+0x520>                
 200dd6c:	80 a2 00 04 	cmp  %o0, %g4                                  
        finished = true;                                              
      }                                                               
    } else if ((sectors_per_cluster * bytes_per_sector)               
 200dd70:	90 10 00 16 	mov  %l6, %o0                                  
 200dd74:	7f ff d2 37 	call  2002650 <.umul>                          
 200dd78:	92 10 00 1b 	mov  %i3, %o1                                  
 200dd7c:	03 00 00 20 	sethi  %hi(0x8000), %g1                        
 200dd80:	80 a2 00 01 	cmp  %o0, %g1                                  
 200dd84:	38 80 00 06 	bgu,a   200dd9c <msdos_format+0x538>           
 200dd88:	d2 07 bd 4c 	ld  [ %fp + -692 ], %o1                        
	> MS_BYTES_PER_CLUSTER_LIMIT) {                                      
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
 200dd8c:	80 8d 60 ff 	btst  0xff, %l5                                
 200dd90:	02 bf ff a3 	be  200dc1c <msdos_format+0x3b8>               
 200dd94:	80 a4 e0 00 	cmp  %l3, 0                                    
                                                                      
  *sectors_per_cluster_adj = sectors_per_cluster;                     
  *sectors_per_fat_ptr     = fat_sectors_cnt / fat_num;               
 200dd98:	d2 07 bd 4c 	ld  [ %fp + -692 ], %o1                        
 200dd9c:	7f ff d2 67 	call  2002738 <.udiv>                          
 200dda0:	90 10 00 11 	mov  %l1, %o0                                  
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 =                       
 200dda4:	09 00 80 ad 	sethi  %hi(0x202b400), %g4                     
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
                                                                      
  *sectors_per_cluster_adj = sectors_per_cluster;                     
  *sectors_per_fat_ptr     = fat_sectors_cnt / fat_num;               
 200dda8:	d0 27 bd bc 	st  %o0, [ %fp + -580 ]                        
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 =                       
 200ddac:	d0 01 22 e0 	ld  [ %g4 + 0x2e0 ], %o0                       
                                                        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;    
 200ddb0:	ec 27 bd b8 	st  %l6, [ %fp + -584 ]                        
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 =                       
 200ddb4:	7f ff d2 61 	call  2002738 <.udiv>                          
 200ddb8:	92 10 00 1b 	mov  %i3, %o1                                  
    ( 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                       
 200ddbc:	80 a2 00 16 	cmp  %o0, %l6                                  
 200ddc0:	2a 80 00 06 	bcs,a   200ddd8 <msdos_format+0x574>           
 200ddc4:	11 00 00 20 	sethi  %hi(0x8000), %o0                        
 200ddc8:	80 a4 2f f4 	cmp  %l0, 0xff4                                
 200ddcc:	08 80 00 0f 	bleu  200de08 <msdos_format+0x5a4>             
 200ddd0:	84 10 20 01 	mov  1, %g2                                    
                    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 =                       
 200ddd4:	11 00 00 20 	sethi  %hi(0x8000), %o0                        
 200ddd8:	92 10 00 1b 	mov  %i3, %o1                                  
 200dddc:	7f ff d2 57 	call  2002738 <.udiv>                          
 200dde0:	90 12 20 01 	or  %o0, 1, %o0                                
                                                                      
  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                  
 200dde4:	80 a2 00 16 	cmp  %o0, %l6                                  
 200dde8:	2a 80 00 08 	bcs,a   200de08 <msdos_format+0x5a4>           
 200ddec:	84 10 20 04 	mov  4, %g2                                    
 200ddf0:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 200ddf4:	82 10 63 f4 	or  %g1, 0x3f4, %g1	! fff4 <PROM_START+0xfff4> 
 200ddf8:	80 a0 40 10 	cmp  %g1, %l0                                  
 200ddfc:	1a 80 00 03 	bcc  200de08 <msdos_format+0x5a4>              
 200de00:	84 10 20 02 	mov  2, %g2                                    
{                                                                     
  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;                                        
 200de04:	84 10 20 04 	mov  4, %g2                                    
          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) {                      
 200de08:	86 0e a0 ff 	and  %i2, 0xff, %g3                            
 200de0c:	82 08 a0 ff 	and  %g2, 0xff, %g1                            
 200de10:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200de14:	02 80 00 19 	be  200de78 <msdos_format+0x614>               
 200de18:	c4 2f bd de 	stb  %g2, [ %fp + -546 ]                       
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 ) {                         
 200de1c:	84 00 bf ff 	add  %g2, -1, %g2                              
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                             
 200de20:	82 10 20 1f 	mov  0x1f, %g1                                 
 200de24:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
 200de28:	80 a0 a0 01 	cmp  %g2, 1                                    
 200de2c:	18 80 00 04 	bgu  200de3c <msdos_format+0x5d8>              
 200de30:	86 10 20 01 	mov  1, %g3                                    
      || fmt_params->fattype == FAT_FAT16 ) {                         
    /* start trying with small clusters */                            
    fmt_params->sectors_per_cluster = 2;                              
 200de34:	10 80 00 0c 	b  200de64 <msdos_format+0x600>                
 200de38:	82 10 20 02 	mov  2, %g1                                    
    #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-- ) {                                      
      if ( (gigs & ( 1 << b) ) != 0 )                                 
 200de3c:	c8 07 bd 40 	ld  [ %fp + -704 ], %g4                        
 200de40:	85 28 c0 01 	sll  %g3, %g1, %g2                             
 200de44:	80 88 80 04 	btst  %g2, %g4                                 
 200de48:	12 80 00 06 	bne  200de60 <msdos_format+0x5fc>              
 200de4c:	84 10 20 01 	mov  1, %g2                                    
  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-- ) {                                      
 200de50:	82 80 7f ff 	addcc  %g1, -1, %g1                            
 200de54:	12 bf ff fc 	bne  200de44 <msdos_format+0x5e0>              <== ALWAYS TAKEN
 200de58:	85 28 c0 01 	sll  %g3, %g1, %g2                             
      if ( (gigs & ( 1 << b) ) != 0 )                                 
        break;                                                        
    }                                                                 
    fmt_params->sectors_per_cluster = 1 << b;                         
 200de5c:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
 200de60:	83 28 80 01 	sll  %g2, %g1, %g1                             
 200de64:	c2 27 bd b8 	st  %g1, [ %fp + -584 ]                        
            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,
 200de68:	90 10 00 19 	mov  %i1, %o0                                  
 200de6c:	7f ff fe 5a 	call  200d7d4 <msdos_set_sectors_per_cluster_from_request>
 200de70:	92 07 bd ac 	add  %fp, -596, %o1                            
 200de74:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                  fmt_params );
          }                                                           
        }                                                             
        if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {   
 200de78:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      
 200de7c:	84 0e a0 ff 	and  %i2, 0xff, %g2                            
 200de80:	80 a0 80 01 	cmp  %g2, %g1                                  
 200de84:	02 80 00 07 	be  200dea0 <msdos_format+0x63c>               
 200de88:	82 0d 20 ff 	and  %l4, 0xff, %g1                            
 200de8c:	80 a0 60 01 	cmp  %g1, 1                                    
 200de90:	08 80 00 04 	bleu  200dea0 <msdos_format+0x63c>             
 200de94:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        
          --fmt_params->totl_sector_cnt;                              
 200de98:	82 00 7f ff 	add  %g1, -1, %g1                              
 200de9c:	c2 27 bd b0 	st  %g1, [ %fp + -592 ]                        
        }                                                             
                                                                      
      }                                                               
                                                                      
      ++iteration_cnt;                                                
 200dea0:	a8 05 20 01 	inc  %l4                                       
    if (ret_val == 0) {                                               
      data_clusters_cnt =                                             
        fmt_params->totl_sector_cnt / fmt_params->sectors_per_cluster;
    }                                                                 
                                                                      
    while(   ret_val == 0                                             
 200dea4:	80 a7 60 00 	cmp  %i5, 0                                    
 200dea8:	12 80 00 09 	bne  200decc <msdos_format+0x668>              <== NEVER TAKEN
 200deac:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      
          && fmt_params->fattype != fat_type                          
 200deb0:	b4 0e a0 ff 	and  %i2, 0xff, %i2                            
 200deb4:	80 a0 40 1a 	cmp  %g1, %i2                                  
 200deb8:	02 80 00 05 	be  200decc <msdos_format+0x668>               
 200debc:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        
          && fmt_params->totl_sector_cnt > 0 ) {                      
 200dec0:	80 a0 60 00 	cmp  %g1, 0                                    
 200dec4:	12 bf ff 02 	bne  200dacc <msdos_format+0x268>              <== ALWAYS TAKEN
 200dec8:	c8 07 bd 48 	ld  [ %fp + -696 ], %g4                        
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
 200decc:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        
 200ded0:	80 a0 60 00 	cmp  %g1, 0                                    
 200ded4:	02 80 00 2f 	be  200df90 <msdos_format+0x72c>               <== NEVER TAKEN
 200ded8:	80 a7 60 00 	cmp  %i5, 0                                    
  {                                                                   
    errno = EINVAL;                                                   
    ret_val = -1;                                                     
  }                                                                   
                                                                      
  if (0 == ret_val)                                                   
 200dedc:	12 80 00 34 	bne  200dfac <msdos_format+0x748>              
 200dee0:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      
  {                                                                   
    if (FAT_FAT32 != fmt_params->fattype)                             
 200dee4:	80 a0 60 04 	cmp  %g1, 4                                    
 200dee8:	02 80 00 0e 	be  200df20 <msdos_format+0x6bc>               
 200deec:	d0 07 bd c8 	ld  [ %fp + -568 ], %o0                        
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200def0:	c4 0f bd fc 	ldub  [ %fp + -516 ], %g2                      
 200def4:	80 a0 a0 00 	cmp  %g2, 0                                    
 200def8:	12 80 00 06 	bne  200df10 <msdos_format+0x6ac>              
 200defc:	c2 07 bd b8 	ld  [ %fp + -584 ], %g1                        
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200df00:	90 02 00 01 	add  %o0, %g1, %o0                             
 200df04:	82 20 00 01 	neg  %g1                                       
 200df08:	90 02 3f ff 	add  %o0, -1, %o0                              
 200df0c:	90 0a 00 01 	and  %o0, %g1, %o0                             
    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);
 200df10:	d2 07 bd ac 	ld  [ %fp + -596 ], %o1                        
 200df14:	7f ff d1 cf 	call  2002650 <.umul>                          
 200df18:	93 32 60 05 	srl  %o1, 5, %o1                               
                                                                      
  if (0 == ret_val)                                                   
  {                                                                   
    if (FAT_FAT32 != fmt_params->fattype)                             
    {                                                                 
      fmt_params->files_per_root_dir = loc_align_object (fmt_params->root_dir_sectors,
 200df1c:	d0 27 bd c4 	st  %o0, [ %fp + -572 ]                        
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200df20:	c6 0f bd fc 	ldub  [ %fp + -516 ], %g3                      
                                                         fmt_params->sectors_per_cluster,
                                                         fmt_params->skip_alignment)
                                       * (fmt_params->bytes_per_sector / FAT_DIRENTRY_SIZE);
    }                                                                 
                                                                      
    fmt_params->rsvd_sector_cnt = loc_align_object (fmt_params->rsvd_sector_cnt,
 200df24:	c2 07 bd b4 	ld  [ %fp + -588 ], %g1                        
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200df28:	80 a0 e0 00 	cmp  %g3, 0                                    
 200df2c:	12 80 00 06 	bne  200df44 <msdos_format+0x6e0>              
 200df30:	c4 07 bd b8 	ld  [ %fp + -584 ], %g2                        
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200df34:	82 00 40 02 	add  %g1, %g2, %g1                             
 200df38:	84 20 00 02 	neg  %g2                                       
 200df3c:	82 00 7f ff 	add  %g1, -1, %g1                              
 200df40:	82 08 40 02 	and  %g1, %g2, %g1                             
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
 200df44:	80 a6 60 00 	cmp  %i1, 0                                    
 200df48:	02 80 00 17 	be  200dfa4 <msdos_format+0x740>               
 200df4c:	c2 27 bd b4 	st  %g1, [ %fp + -588 ]                        
	(rqdata->media != 0)) {                                              
 200df50:	f6 0e 60 14 	ldub  [ %i1 + 0x14 ], %i3                      
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
 200df54:	b4 8e e0 ff 	andcc  %i3, 0xff, %i2                          
 200df58:	02 80 00 14 	be  200dfa8 <msdos_format+0x744>               
 200df5c:	82 10 3f f8 	mov  -8, %g1                                   
	(rqdata->media != 0)) {                                              
      const char valid_media_codes[] =                                
 200df60:	94 10 20 09 	mov  9, %o2                                    
 200df64:	90 07 be 00 	add  %fp, -512, %o0                            
 200df68:	13 00 80 ad 	sethi  %hi(0x202b400), %o1                     
 200df6c:	40 00 38 4f 	call  201c0a8 <memcpy>                         
 200df70:	92 12 62 d0 	or  %o1, 0x2d0, %o1	! 202b6d0 <_CPU_Trap_slot_template+0x188>
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
      if (NULL==memchr(valid_media_codes,                             
 200df74:	90 07 be 00 	add  %fp, -512, %o0                            
 200df78:	92 10 00 1a 	mov  %i2, %o1                                  
 200df7c:	40 00 37 dd 	call  201bef0 <memchr>                         
 200df80:	94 10 20 09 	mov  9, %o2                                    
 200df84:	80 a2 20 00 	cmp  %o0, 0                                    
 200df88:	32 80 00 09 	bne,a   200dfac <msdos_format+0x748>           <== NEVER TAKEN
 200df8c:	f6 2f bd dd 	stb  %i3, [ %fp + -547 ]                       <== NOT EXECUTED
		       rqdata->media,                                               
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
 200df90:	40 00 35 87 	call  201b5ac <__errno>                        
 200df94:	ba 10 3f ff 	mov  -1, %i5                                   
 200df98:	82 10 20 16 	mov  0x16, %g1                                 
 200df9c:	10 80 00 04 	b  200dfac <msdos_format+0x748>                
 200dfa0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
 200dfa4:	82 10 3f f8 	mov  -8, %g1                                   
 200dfa8:	c2 2f bd dd 	stb  %g1, [ %fp + -547 ]                       
  }                                                                   
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
 200dfac:	f4 07 bd c8 	ld  [ %fp + -568 ], %i2                        
 200dfb0:	d0 0f bd dc 	ldub  [ %fp + -548 ], %o0                      
 200dfb4:	80 a6 a0 00 	cmp  %i2, 0                                    
 200dfb8:	f6 07 bd b4 	ld  [ %fp + -588 ], %i3                        
    fmt_params->root_dir_start_sec =                                  
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
 200dfbc:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
  }                                                                   
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
 200dfc0:	02 80 00 08 	be  200dfe0 <msdos_format+0x77c>               
 200dfc4:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        
    fmt_params->root_dir_start_sec =                                  
      fmt_params->rsvd_sector_cnt                                     
      + (fmt_params-> fat_num*fmt_params->sectors_per_fat);           
 200dfc8:	7f ff d1 a2 	call  2002650 <.umul>                          
 200dfcc:	01 00 00 00 	nop                                            
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;  
 200dfd0:	f4 27 bd d0 	st  %i2, [ %fp + -560 ]                        
   * 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);           
 200dfd4:	90 02 00 1b 	add  %o0, %i3, %o0                             
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
    fmt_params->root_dir_start_sec =                                  
 200dfd8:	10 80 00 08 	b  200dff8 <msdos_format+0x794>                
 200dfdc:	d0 27 bd cc 	st  %o0, [ %fp + -564 ]                        
    /*                                                                
     * 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);           
 200dfe0:	7f ff d1 9c 	call  2002650 <.umul>                          
 200dfe4:	01 00 00 00 	nop                                            
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
 200dfe8:	c2 07 bd b8 	ld  [ %fp + -584 ], %g1                        
    /*                                                                
     * 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);           
 200dfec:	90 02 00 1b 	add  %o0, %i3, %o0                             
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
 200dff0:	c2 27 bd d0 	st  %g1, [ %fp + -560 ]                        
  }                                                                   
  else {                                                              
    /*                                                                
     * for FAT32: root directory is in cluster 2                      
     */                                                               
    fmt_params->root_dir_start_sec =                                  
 200dff4:	d0 27 bd cc 	st  %o0, [ %fp + -564 ]                        
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
  }                                                                   
  /*                                                                  
   * determine usable OEMName                                         
   */                                                                 
  if (ret_val == 0) {                                                 
 200dff8:	80 a7 60 00 	cmp  %i5, 0                                    
 200dffc:	12 80 00 48 	bne  200e11c <msdos_format+0x8b8>              
 200e000:	80 a0 00 19 	cmp  %g0, %i1                                  
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
      int          cnt;                                               
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
 200e004:	80 a6 60 00 	cmp  %i1, 0                                    
 200e008:	02 80 00 07 	be  200e024 <msdos_format+0x7c0>               
 200e00c:	03 00 80 ad 	sethi  %hi(0x202b400), %g1                     
	(rqdata->OEMName != NULL)) {                                         
 200e010:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  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) &&                                           
 200e014:	80 a0 60 00 	cmp  %g1, 0                                    
 200e018:	32 80 00 05 	bne,a   200e02c <msdos_format+0x7c8>           
 200e01c:	05 00 80 b4 	sethi  %hi(0x202d000), %g2                     
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
      int          cnt;                                               
      from = "RTEMS"; /* default: make "from" point to OS Name */     
 200e020:	03 00 80 ad 	sethi  %hi(0x202b400), %g1                     
 200e024:	82 10 61 88 	or  %g1, 0x188, %g1	! 202b588 <_CPU_Trap_slot_template+0x40>
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
 200e028:	05 00 80 b4 	sethi  %hi(0x202d000), %g2                     
 200e02c:	86 10 20 09 	mov  9, %g3                                    
 200e030:	f4 00 a0 08 	ld  [ %g2 + 8 ], %i2                           
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
 200e034:	b0 10 20 20 	mov  0x20, %i0                                 
  /*                                                                  
   * determine usable OEMName                                         
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
 200e038:	10 80 00 0f 	b  200e074 <msdos_format+0x810>                
 200e03c:	84 07 bd df 	add  %fp, -545, %g2                            
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
 200e040:	88 0e e0 ff 	and  %i3, 0xff, %g4                            
 200e044:	88 06 80 04 	add  %i2, %g4, %g4                             
 200e048:	c8 49 20 01 	ldsb  [ %g4 + 1 ], %g4                         
 200e04c:	80 89 20 97 	btst  0x97, %g4                                
 200e050:	02 80 00 06 	be  200e068 <msdos_format+0x804>               
 200e054:	88 00 a0 01 	add  %g2, 1, %g4                               
	*to++ = *from++;                                                     
 200e058:	f6 28 80 00 	stb  %i3, [ %g2 ]                              
 200e05c:	82 00 60 01 	inc  %g1                                       
 200e060:	10 80 00 04 	b  200e070 <msdos_format+0x80c>                
 200e064:	84 10 00 04 	mov  %g4, %g2                                  
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
 200e068:	f0 28 80 00 	stb  %i0, [ %g2 ]                              
 200e06c:	84 10 00 04 	mov  %g4, %g2                                  
      }                                                               
      *to = '\0';                                                     
 200e070:	c0 29 00 00 	clrb  [ %g4 ]                                  
      from = "RTEMS"; /* default: make "from" point to OS Name */     
    if ((rqdata != NULL) &&                                           
	(rqdata->OEMName != NULL)) {                                         
      from = rqdata->OEMName;                                         
    }                                                                 
    for (cnt = 0;                                                     
 200e074:	86 80 ff ff 	addcc  %g3, -1, %g3                            
 200e078:	32 bf ff f2 	bne,a   200e040 <msdos_format+0x7dc>           
 200e07c:	f6 08 40 00 	ldub  [ %g1 ], %i3                             
  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) &&                                           
 200e080:	10 80 01 b6 	b  200e758 <msdos_format+0xef4>                
 200e084:	80 a6 60 00 	cmp  %i1, 0                                    
 200e088:	80 a0 60 00 	cmp  %g1, 0                                    
 200e08c:	22 80 00 05 	be,a   200e0a0 <msdos_format+0x83c>            
 200e090:	03 00 80 aa 	sethi  %hi(0x202a800), %g1                     
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
 200e094:	84 10 20 01 	mov  1, %g2                                    
 200e098:	10 80 00 03 	b  200e0a4 <msdos_format+0x840>                
 200e09c:	c4 2f bd f4 	stb  %g2, [ %fp + -524 ]                       
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
 200e0a0:	82 10 63 f8 	or  %g1, 0x3f8, %g1                            
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
 200e0a4:	05 00 80 b4 	sethi  %hi(0x202d000), %g2                     
 200e0a8:	86 10 20 0c 	mov  0xc, %g3                                  
 200e0ac:	f4 00 a0 08 	ld  [ %g2 + 8 ], %i2                           
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
 200e0b0:	b0 10 20 20 	mov  0x20, %i0                                 
  /*                                                                  
   * determine usable Volume Label                                    
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
 200e0b4:	10 80 00 0f 	b  200e0f0 <msdos_format+0x88c>                
 200e0b8:	84 07 bd e8 	add  %fp, -536, %g2                            
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
 200e0bc:	88 0e e0 ff 	and  %i3, 0xff, %g4                            
 200e0c0:	88 06 80 04 	add  %i2, %g4, %g4                             
 200e0c4:	c8 49 20 01 	ldsb  [ %g4 + 1 ], %g4                         
 200e0c8:	80 89 20 97 	btst  0x97, %g4                                
 200e0cc:	02 80 00 06 	be  200e0e4 <msdos_format+0x880>               
 200e0d0:	88 00 a0 01 	add  %g2, 1, %g4                               
	*to++ = *from++;                                                     
 200e0d4:	f6 28 80 00 	stb  %i3, [ %g2 ]                              
 200e0d8:	82 00 60 01 	inc  %g1                                       
 200e0dc:	10 80 00 04 	b  200e0ec <msdos_format+0x888>                
 200e0e0:	84 10 00 04 	mov  %g4, %g2                                  
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
 200e0e4:	f0 28 80 00 	stb  %i0, [ %g2 ]                              
 200e0e8:	84 10 00 04 	mov  %g4, %g2                                  
      }                                                               
      *to = '\0';                                                     
 200e0ec:	c0 29 00 00 	clrb  [ %g4 ]                                  
    if ((rqdata != NULL) &&                                           
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
    }                                                                 
    for (cnt = 0;                                                     
 200e0f0:	86 80 ff ff 	addcc  %g3, -1, %g3                            
 200e0f4:	32 bf ff f2 	bne,a   200e0bc <msdos_format+0x858>           
 200e0f8:	f6 08 40 00 	ldub  [ %g1 ], %i3                             
 200e0fc:	30 80 01 9b 	b,a   200e768 <msdos_format+0xf04>             
  int rc;                                                             
  struct timeval time_value;                                          
                                                                      
  rc = rtems_clock_get_tod_timeval(&time_value);                      
  if (rc == RTEMS_SUCCESSFUL) {                                       
    *volid_ptr = time_value.tv_sec + time_value.tv_sec;               
 200e100:	83 28 60 01 	sll  %g1, 1, %g1                               <== NOT EXECUTED
 200e104:	10 80 00 05 	b  200e118 <msdos_format+0x8b4>                <== NOT EXECUTED
 200e108:	c2 27 bd f8 	st  %g1, [ %fp + -520 ]                        <== NOT EXECUTED
  }                                                                   
  else {                                                              
    *volid_ptr = rand();                                              
 200e10c:	40 00 3a af 	call  201cbc8 <rand>                           
 200e110:	01 00 00 00 	nop                                            
 200e114:	d0 27 bd f8 	st  %o0, [ %fp + -520 ]                        
  }                                                                   
  /*                                                                  
   * if requested, write whole disk/partition with 0xe5               
   */                                                                 
  if ((ret_val == 0) &&                                               
      (rqdata != NULL) &&                                             
 200e118:	80 a0 00 19 	cmp  %g0, %i1                                  
 200e11c:	b4 40 20 00 	addx  %g0, 0, %i2                              
    ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
  }                                                                   
  /*                                                                  
   * if requested, write whole disk/partition with 0xe5               
   */                                                                 
  if ((ret_val == 0) &&                                               
 200e120:	80 a7 60 00 	cmp  %i5, 0                                    
 200e124:	12 80 01 5f 	bne  200e6a0 <msdos_format+0xe3c>              
 200e128:	b0 10 00 1d 	mov  %i5, %i0                                  
 200e12c:	80 8e a0 ff 	btst  0xff, %i2                                
 200e130:	02 80 00 1d 	be  200e1a4 <msdos_format+0x940>               
 200e134:	80 a7 60 00 	cmp  %i5, 0                                    
      (rqdata != NULL) &&                                             
 200e138:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
 200e13c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e140:	02 80 00 11 	be  200e184 <msdos_format+0x920>               
 200e144:	90 10 00 19 	mov  %i1, %o0                                  
   */                                                                 
  if (ret_val == 0) {                                                 
    /*                                                                
     * Read the current MBR to obtain the partition table.            
     */                                                               
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
 200e148:	92 10 20 02 	mov  2, %o1                                    
 200e14c:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200e150:	7f ff fd 29 	call  200d5f4 <msdos_format_printf>            
 200e154:	94 12 a2 40 	or  %o2, 0x240, %o2	! 202b640 <_CPU_Trap_slot_template+0xf8>
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
 200e158:	90 10 00 1c 	mov  %i4, %o0                                  
    /*                                                                
     * 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,                               
 200e15c:	fa 07 bd ac 	ld  [ %fp + -596 ], %i5                        
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
 200e160:	92 10 20 00 	clr  %o1                                       
 200e164:	94 10 20 00 	clr  %o2                                       
 200e168:	40 00 1a 4d 	call  2014a9c <lseek>                          
 200e16c:	96 10 20 00 	clr  %o3                                       
 200e170:	80 a2 20 00 	cmp  %o0, 0                                    
 200e174:	16 80 01 83 	bge  200e780 <msdos_format+0xf1c>              <== ALWAYS TAKEN
 200e178:	90 10 00 1c 	mov  %i4, %o0                                  
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
  {                                                                   
    errno = EINVAL;                                                   
    ret_val = -1;                                                     
 200e17c:	10 80 01 89 	b  200e7a0 <msdos_format+0xf3c>                <== NOT EXECUTED
 200e180:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
   * if requested, write whole disk/partition with 0xe5               
   */                                                                 
  if ((ret_val == 0) &&                                               
      (rqdata != NULL) &&                                             
      !(rqdata->quick_format)) {                                      
    ret_val = msdos_format_fill_sectors                               
 200e184:	d6 07 bd b0 	ld  [ %fp + -592 ], %o3                        
 200e188:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        
 200e18c:	92 10 00 1c 	mov  %i4, %o1                                  
 200e190:	94 10 20 00 	clr  %o2                                       
 200e194:	7f ff fd 45 	call  200d6a8 <msdos_format_fill_sectors>      
 200e198:	9a 10 3f e5 	mov  -27, %o5                                  
 200e19c:	ba 10 00 08 	mov  %o0, %i5                                  
  }                                                                   
                                                                      
  /*                                                                  
   * create master boot record                                        
   */                                                                 
  if (ret_val == 0) {                                                 
 200e1a0:	80 a7 60 00 	cmp  %i5, 0                                    
 200e1a4:	12 80 01 3f 	bne  200e6a0 <msdos_format+0xe3c>              <== NEVER TAKEN
 200e1a8:	b0 10 00 1d 	mov  %i5, %i0                                  
    /*                                                                
     * Read the current MBR to obtain the partition table.            
     */                                                               
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
 200e1ac:	10 bf ff e7 	b  200e148 <msdos_format+0x8e4>                
 200e1b0:	90 10 00 19 	mov  %i1, %o0                                  
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  uint32_t  total_sectors_num16 = 0;                                  
  uint32_t  total_sectors_num32 = 0;                                  
 200e1b4:	ba 10 20 00 	clr  %i5                                       
   * 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);                     
 200e1b8:	92 10 20 00 	clr  %o1                                       
 200e1bc:	94 10 21 be 	mov  0x1be, %o2                                
 200e1c0:	40 00 37 f7 	call  201c19c <memset>                         
 200e1c4:	90 07 be 00 	add  %fp, -512, %o0                            
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
 200e1c8:	90 07 be 03 	add  %fp, -509, %o0                            
   * 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,
 200e1cc:	c0 37 bf fe 	clrh  [ %fp + -2 ]                             
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
 200e1d0:	92 07 bd df 	add  %fp, -545, %o1                            
 200e1d4:	40 00 37 b5 	call  201c0a8 <memcpy>                         
 200e1d8:	94 10 20 08 	mov  8, %o2                                    
	 fmt_params->OEMName,                                                
	 FAT_BR_OEMNAME_SIZE);                                               
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
 200e1dc:	c2 07 bd ac 	ld  [ %fp + -596 ], %g1                        
                                                                      
  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);          
 200e1e0:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
   * 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); 
 200e1e4:	c2 2f be 0b 	stb  %g1, [ %fp + -501 ]                       
 200e1e8:	83 30 60 08 	srl  %g1, 8, %g1                               
 200e1ec:	c2 2f be 0c 	stb  %g1, [ %fp + -500 ]                       
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
 200e1f0:	c2 07 bd b8 	ld  [ %fp + -584 ], %g1                        
                                                                      
  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);          
 200e1f4:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
   */                                                                 
  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);
 200e1f8:	c2 2f be 0d 	stb  %g1, [ %fp + -499 ]                       
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
 200e1fc:	c2 07 bd b4 	ld  [ %fp + -588 ], %g1                        
                                                                      
  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);          
 200e200:	fa 2f be 20 	stb  %i5, [ %fp + -480 ]                       
  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);  
 200e204:	c2 2f be 0e 	stb  %g1, [ %fp + -498 ]                       
 200e208:	83 30 60 08 	srl  %g1, 8, %g1                               
 200e20c:	c2 2f be 0f 	stb  %g1, [ %fp + -497 ]                       
                                                                      
  /* 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);
 200e210:	c2 07 bd c4 	ld  [ %fp + -572 ], %g1                        
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
 200e214:	88 10 20 02 	mov  2, %g4                                    
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
 200e218:	c2 2f be 11 	stb  %g1, [ %fp + -495 ]                       
 200e21c:	83 30 60 08 	srl  %g1, 8, %g1                               
 200e220:	c2 2f be 12 	stb  %g1, [ %fp + -494 ]                       
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
 200e224:	c2 0f bd dd 	ldub  [ %fp + -547 ], %g1                      
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
 200e228:	f6 2f be 13 	stb  %i3, [ %fp + -493 ]                       
  FAT_SET_BR_MEDIA(mbr               , fmt_params->media_code);       
 200e22c:	c2 2f be 15 	stb  %g1, [ %fp + -491 ]                       
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
 200e230:	82 10 3f ff 	mov  -1, %g1                                   
 200e234:	c2 2f be 18 	stb  %g1, [ %fp + -488 ]                       
  FAT_SET_BR_NUMBER_OF_HEADS(mbr     , 6);   /* only needed for INT13... */
 200e238:	82 10 20 06 	mov  6, %g1                                    
 200e23c:	c2 2f be 1a 	stb  %g1, [ %fp + -486 ]                       
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
 200e240:	82 0f 40 02 	and  %i5, %g2, %g1                             
 200e244:	83 30 60 08 	srl  %g1, 8, %g1                               
 200e248:	c2 2f be 21 	stb  %g1, [ %fp + -479 ]                       
 200e24c:	83 37 60 10 	srl  %i5, 0x10, %g1                            
 200e250:	bb 37 60 18 	srl  %i5, 0x18, %i5                            
 200e254:	fa 2f be 23 	stb  %i5, [ %fp + -477 ]                       
  if (fmt_params->fattype != FAT_FAT32) {                             
 200e258:	fa 0f bd de 	ldub  [ %fp + -546 ], %i5                      
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
 200e25c:	b7 36 e0 08 	srl  %i3, 8, %i3                               
  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... */
 200e260:	86 10 20 01 	mov  1, %g3                                    
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
 200e264:	c2 2f be 22 	stb  %g1, [ %fp + -478 ]                       
  FAT_SET_BR_BYTES_PER_SECTOR(mbr    , fmt_params->bytes_per_sector); 
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
                                                                      
  /* number of FATs on medium */                                      
  FAT_SET_BR_FAT_NUM(mbr             , 2); /* standard/recommended value */
 200e268:	c8 2f be 10 	stb  %g4, [ %fp + -496 ]                       
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
 200e26c:	f6 2f be 14 	stb  %i3, [ %fp + -492 ]                       
  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... */
 200e270:	c6 2f be 1c 	stb  %g3, [ %fp + -484 ]                       
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
  if (fmt_params->fattype != FAT_FAT32) {                             
 200e274:	80 a7 60 04 	cmp  %i5, 4                                    
 200e278:	02 80 00 1c 	be  200e2e8 <msdos_format+0xa84>               
 200e27c:	c2 07 bd bc 	ld  [ %fp + -580 ], %g1                        
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
 200e280:	c2 2f be 16 	stb  %g1, [ %fp + -490 ]                       
 200e284:	83 30 60 08 	srl  %g1, 8, %g1                               
 200e288:	c2 2f be 17 	stb  %g1, [ %fp + -489 ]                       
    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);           
 200e28c:	82 10 20 29 	mov  0x29, %g1                                 
 200e290:	c2 2f be 26 	stb  %g1, [ %fp + -474 ]                       
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
 200e294:	c2 07 bd f8 	ld  [ %fp + -520 ], %g1                        
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
 200e298:	92 07 bd e8 	add  %fp, -536, %o1                            
  if (fmt_params->fattype != FAT_FAT32) {                             
    FAT_SET_BR_SECTORS_PER_FAT(mbr   ,fmt_params->sectors_per_fat);   
    FAT_SET_BR_DRVNUM(mbr            , 0); /* only needed for INT13... */
    FAT_SET_BR_RSVD1(mbr             , 0); /* fill with zero */       
    FAT_SET_BR_BOOTSIG(mbr           , FAT_BR_BOOTSIG_VAL);           
    FAT_SET_BR_VOLID(mbr             , fmt_params->vol_id); /* volume id */
 200e29c:	84 08 40 02 	and  %g1, %g2, %g2                             
 200e2a0:	85 30 a0 08 	srl  %g2, 8, %g2                               
 200e2a4:	c2 2f be 27 	stb  %g1, [ %fp + -473 ]                       
 200e2a8:	c4 2f be 28 	stb  %g2, [ %fp + -472 ]                       
 200e2ac:	85 30 60 10 	srl  %g1, 0x10, %g2                            
 200e2b0:	83 30 60 18 	srl  %g1, 0x18, %g1                            
 200e2b4:	c4 2f be 29 	stb  %g2, [ %fp + -471 ]                       
 200e2b8:	c2 2f be 2a 	stb  %g1, [ %fp + -470 ]                       
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
 200e2bc:	90 07 be 2b 	add  %fp, -469, %o0                            
 200e2c0:	40 00 37 7a 	call  201c0a8 <memcpy>                         
 200e2c4:	94 10 20 0b 	mov  0xb, %o2                                  
	 fmt_params->VolLabel,                                               
	 FAT_BR_VOLLAB_SIZE);                                                
    memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),                           
 200e2c8:	13 00 80 ad 	sethi  %hi(0x202b400), %o1                     
 200e2cc:	80 a7 60 01 	cmp  %i5, 1                                    
 200e2d0:	12 80 00 04 	bne  200e2e0 <msdos_format+0xa7c>              
 200e2d4:	92 12 61 a0 	or  %o1, 0x1a0, %o1                            
 200e2d8:	13 00 80 ad 	sethi  %hi(0x202b400), %o1                     
 200e2dc:	92 12 61 90 	or  %o1, 0x190, %o1	! 202b590 <_CPU_Trap_slot_template+0x48>
 200e2e0:	10 80 00 1d 	b  200e354 <msdos_format+0xaf0>                
 200e2e4:	90 07 be 36 	add  %fp, -458, %o0                            
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
 200e2e8:	84 08 40 02 	and  %g1, %g2, %g2                             
 200e2ec:	85 30 a0 08 	srl  %g2, 8, %g2                               
 200e2f0:	c2 2f be 24 	stb  %g1, [ %fp + -476 ]                       
 200e2f4:	c4 2f be 25 	stb  %g2, [ %fp + -475 ]                       
 200e2f8:	85 30 60 10 	srl  %g1, 0x10, %g2                            
 200e2fc:	83 30 60 18 	srl  %g1, 0x18, %g1                            
 200e300:	c2 2f be 27 	stb  %g1, [ %fp + -473 ]                       
    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 */
 200e304:	c2 07 bd d4 	ld  [ %fp + -556 ], %g1                        
	   ? "FAT12   "                                                      
	   : "FAT16   ",                                                     
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
 200e308:	c4 2f be 26 	stb  %g2, [ %fp + -474 ]                       
    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 */
 200e30c:	c2 2f be 32 	stb  %g1, [ %fp + -462 ]                       
 200e310:	83 30 60 08 	srl  %g1, 8, %g1                               
  }                                                                   
  else {                                                              
    FAT_SET_BR_SECTORS_PER_FAT32(mbr   ,fmt_params->sectors_per_fat); 
    FAT_SET_BR_EXT_FLAGS(mbr           , 0);                          
    FAT_SET_BR_FSVER(mbr               , 0); /* FAT32 Version:0.0 */  
    FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr  , 2); /* put root dir to cluster 2 */
 200e314:	c8 2f be 2c 	stb  %g4, [ %fp + -468 ]                       
    FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo  to rsrvd sec 1*/
 200e318:	c6 2f be 30 	stb  %g3, [ %fp + -464 ]                       
    FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
 200e31c:	c2 2f be 33 	stb  %g1, [ %fp + -461 ]                       
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
 200e320:	92 10 20 00 	clr  %o1                                       
 200e324:	94 10 20 0c 	mov  0xc, %o2                                  
 200e328:	40 00 37 9d 	call  201c19c <memset>                         
 200e32c:	90 07 be 34 	add  %fp, -460, %o0                            
                                                                      
    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);      
 200e330:	82 10 20 29 	mov  0x29, %g1                                 
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
    memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr)   ,0,FAT_BR_VOLLAB_SIZE);
 200e334:	92 10 20 00 	clr  %o1                                       
    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);      
 200e338:	c2 2f be 42 	stb  %g1, [ %fp + -446 ]                       
    FAT_SET_BR_FAT32_VOLID(mbr       , 0); /* not set */              
    memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr)   ,0,FAT_BR_VOLLAB_SIZE);
 200e33c:	90 07 be 47 	add  %fp, -441, %o0                            
 200e340:	40 00 37 97 	call  201c19c <memset>                         
 200e344:	94 10 20 0b 	mov  0xb, %o2                                  
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
 200e348:	13 00 80 ad 	sethi  %hi(0x202b400), %o1                     
 200e34c:	90 07 be 52 	add  %fp, -430, %o0                            
 200e350:	92 12 62 58 	or  %o1, 0x258, %o1                            
 200e354:	40 00 37 55 	call  201c0a8 <memcpy>                         
 200e358:	94 10 20 08 	mov  8, %o2                                    
	   FAT_BR_FILSYSTYPE_SIZE);                                          
  }                                                                   
  /*                                                                  
   * add boot record signature                                        
   */                                                                 
  FAT_SET_BR_SIGNATURE(mbr,      FAT_BR_SIGNATURE_VAL);               
 200e35c:	82 10 20 55 	mov  0x55, %g1                                 
 200e360:	c2 2f bf fe 	stb  %g1, [ %fp + -2 ]                         
 200e364:	82 10 3f aa 	mov  -86, %g1                                  
 200e368:	c2 2f bf ff 	stb  %g1, [ %fp + -1 ]                         
                                                                      
  /*                                                                  
   * add jump to boot loader at start of sector                       
   */                                                                 
  FAT_SET_VAL8(mbr,0,0xeb);                                           
 200e36c:	82 10 3f eb 	mov  -21, %g1                                  
 200e370:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       
  FAT_SET_VAL8(mbr,1,0x3c);                                           
 200e374:	82 10 20 3c 	mov  0x3c, %g1                                 
 200e378:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       
  FAT_SET_VAL8(mbr,2,0x90);                                           
 200e37c:	82 10 3f 90 	mov  -112, %g1                                 
    /*                                                                
     * 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,       
 200e380:	90 10 00 19 	mov  %i1, %o0                                  
  /*                                                                  
   * 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);                                           
 200e384:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       
    /*                                                                
     * 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,       
 200e388:	92 10 20 02 	mov  2, %o1                                    
 200e38c:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200e390:	7f ff fc 99 	call  200d5f4 <msdos_format_printf>            
 200e394:	94 12 a2 68 	or  %o2, 0x268, %o2	! 202b668 <_CPU_Trap_slot_template+0x120>
                           "write MRB sector\n");                     
      ret_val = msdos_format_write_sec(fd,                            
 200e398:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        
 200e39c:	90 10 00 1c 	mov  %i4, %o0                                  
 200e3a0:	92 10 20 00 	clr  %o1                                       
 200e3a4:	7f ff fc a9 	call  200d648 <msdos_format_write_sec>         
 200e3a8:	96 07 be 00 	add  %fp, -512, %o3                            
                                       0,                             
                                       fmt_params.bytes_per_sector,   
                                       tmp_sec);                      
    }                                                                 
    if ((ret_val == 0) &&                                             
 200e3ac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e3b0:	12 80 00 fc 	bne  200e7a0 <msdos_format+0xf3c>              <== NEVER TAKEN
 200e3b4:	c2 07 bd d4 	ld  [ %fp + -556 ], %g1                        
 200e3b8:	80 a0 60 00 	cmp  %g1, 0                                    
 200e3bc:	12 80 00 08 	bne  200e3dc <msdos_format+0xb78>              
 200e3c0:	90 10 00 19 	mov  %i1, %o0                                  
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
 200e3c4:	fa 07 bd d8 	ld  [ %fp + -552 ], %i5                        
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
 200e3c8:	80 a7 60 00 	cmp  %i5, 0                                    
 200e3cc:	22 80 00 37 	be,a   200e4a8 <msdos_format+0xc44>            
 200e3d0:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        
\*=========================================================================*/
{                                                                     
  /*                                                                  
   * clear fsinfo sector data                                         
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
 200e3d4:	10 80 00 10 	b  200e414 <msdos_format+0xbb0>                
 200e3d8:	92 10 20 00 	clr  %o1                                       
    if ((ret_val == 0) &&                                             
        (fmt_params.mbr_copy_sec != 0)) {                             
      /*                                                              
       * write copy of MBR                                            
       */                                                             
      msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,       
 200e3dc:	92 10 20 02 	mov  2, %o1                                    
 200e3e0:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200e3e4:	7f ff fc 84 	call  200d5f4 <msdos_format_printf>            
 200e3e8:	94 12 a2 80 	or  %o2, 0x280, %o2	! 202b680 <_CPU_Trap_slot_template+0x138>
                           "write back up MRB sector\n");             
      ret_val = msdos_format_write_sec(fd,                            
 200e3ec:	d2 07 bd d4 	ld  [ %fp + -556 ], %o1                        
 200e3f0:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        
 200e3f4:	90 10 00 1c 	mov  %i4, %o0                                  
 200e3f8:	7f ff fc 94 	call  200d648 <msdos_format_write_sec>         
 200e3fc:	96 07 be 00 	add  %fp, -512, %o3                            
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
 200e400:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e404:	22 bf ff f1 	be,a   200e3c8 <msdos_format+0xb64>            <== ALWAYS TAKEN
 200e408:	fa 07 bd d8 	ld  [ %fp + -552 ], %i5                        
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
 200e40c:	10 80 00 a5 	b  200e6a0 <msdos_format+0xe3c>                <== NOT EXECUTED
 200e410:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
\*=========================================================================*/
{                                                                     
  /*                                                                  
   * clear fsinfo sector data                                         
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
 200e414:	94 10 22 00 	mov  0x200, %o2                                
 200e418:	40 00 37 61 	call  201c19c <memset>                         
 200e41c:	90 07 be 00 	add  %fp, -512, %o0                            
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
 200e420:	82 10 20 52 	mov  0x52, %g1                                 
 200e424:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       
 200e428:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       
 200e42c:	82 10 20 61 	mov  0x61, %g1                                 
 200e430:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
 200e434:	c2 2f bf e7 	stb  %g1, [ %fp + -25 ]                        
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
 200e438:	82 10 20 55 	mov  0x55, %g1                                 
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
    ret_val = msdos_format_write_sec(fd,                              
 200e43c:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
 200e440:	c2 2f bf fe 	stb  %g1, [ %fp + -2 ]                         
 200e444:	82 10 3f aa 	mov  -86, %g1                                  
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
 200e448:	84 10 20 41 	mov  0x41, %g2                                 
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
 200e44c:	86 10 20 72 	mov  0x72, %g3                                 
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
 200e450:	c2 2f bf ff 	stb  %g1, [ %fp + -1 ]                         
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
 200e454:	82 10 3f ff 	mov  -1, %g1                                   
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
    ret_val = msdos_format_write_sec(fd,                              
 200e458:	92 10 00 1d 	mov  %i5, %o1                                  
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
  /*                                                                  
   * write LEADSIG, STRUCTSIG, TRAILSIG                               
   */                                                                 
  FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
 200e45c:	c4 2f be 03 	stb  %g2, [ %fp + -509 ]                       
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
 200e460:	c6 2f bf e4 	stb  %g3, [ %fp + -28 ]                        
 200e464:	c6 2f bf e5 	stb  %g3, [ %fp + -27 ]                        
 200e468:	c4 2f bf e6 	stb  %g2, [ %fp + -26 ]                        
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
  /*                                                                  
   * write "empty" values for free cluster count and next cluster number
   */                                                                 
  FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,              
 200e46c:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
 200e470:	c2 2f bf e9 	stb  %g1, [ %fp + -23 ]                        
 200e474:	c2 2f bf ea 	stb  %g1, [ %fp + -22 ]                        
 200e478:	c2 2f bf eb 	stb  %g1, [ %fp + -21 ]                        
				    0xffffffff);                                                  
  FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,              
 200e47c:	c2 2f bf ec 	stb  %g1, [ %fp + -20 ]                        
 200e480:	c2 2f bf ed 	stb  %g1, [ %fp + -19 ]                        
 200e484:	c2 2f bf ee 	stb  %g1, [ %fp + -18 ]                        
 200e488:	c2 2f bf ef 	stb  %g1, [ %fp + -17 ]                        
  /*                                                                  
   * write fsinfo sector                                              
   */                                                                 
  if ((ret_val == 0) &&                                               
      (fmt_params.fsinfo_sec != 0)) {                                 
    ret_val = msdos_format_write_sec(fd,                              
 200e48c:	90 10 00 1c 	mov  %i4, %o0                                  
 200e490:	7f ff fc 6e 	call  200d648 <msdos_format_write_sec>         
 200e494:	96 07 be 00 	add  %fp, -512, %o3                            
  }                                                                   
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
 200e498:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e49c:	12 80 00 81 	bne  200e6a0 <msdos_format+0xe3c>              <== NEVER TAKEN
 200e4a0:	b0 10 00 1d 	mov  %i5, %i0                                  
    ret_val = msdos_format_fill_sectors                               
      (rqdata,                                                        
 200e4a4:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        
 200e4a8:	d0 0f bd dc 	ldub  [ %fp + -548 ], %o0                      
 200e4ac:	7f ff d0 69 	call  2002650 <.umul>                          
 200e4b0:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
    ret_val = msdos_format_fill_sectors                               
 200e4b4:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        
      (rqdata,                                                        
 200e4b8:	96 10 00 08 	mov  %o0, %o3                                  
  /*                                                                  
   * write FAT as all empty                                           
   * -> write all FAT sectors as zero                                 
   */                                                                 
  if (ret_val == 0) {                                                 
    ret_val = msdos_format_fill_sectors                               
 200e4bc:	94 10 00 1d 	mov  %i5, %o2                                  
 200e4c0:	90 10 00 19 	mov  %i1, %o0                                  
 200e4c4:	92 10 00 1c 	mov  %i4, %o1                                  
 200e4c8:	7f ff fc 78 	call  200d6a8 <msdos_format_fill_sectors>      
 200e4cc:	9a 10 20 00 	clr  %o5                                       
  }                                                                   
  /*                                                                  
   * clear/init root directory                                        
   * -> write all directory sectors as 0x00                           
   */                                                                 
  if (ret_val == 0) {                                                 
 200e4d0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e4d4:	12 80 00 b3 	bne  200e7a0 <msdos_format+0xf3c>              <== NEVER TAKEN
 200e4d8:	d4 07 bd cc 	ld  [ %fp + -564 ], %o2                        
    ret_val = msdos_format_fill_sectors                               
 200e4dc:	d6 07 bd d0 	ld  [ %fp + -560 ], %o3                        
 200e4e0:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        
 200e4e4:	90 10 00 19 	mov  %i1, %o0                                  
 200e4e8:	92 10 00 1c 	mov  %i4, %o1                                  
 200e4ec:	7f ff fc 6f 	call  200d6a8 <msdos_format_fill_sectors>      
 200e4f0:	9a 10 20 00 	clr  %o5                                       
       0x00);                                                         
  }                                                                   
  /*                                                                  
   * write volume label to first entry of directory                   
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present) {                
 200e4f4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e4f8:	12 80 00 aa 	bne  200e7a0 <msdos_format+0xf3c>              <== NEVER TAKEN
 200e4fc:	c2 0f bd f4 	ldub  [ %fp + -524 ], %g1                      
 200e500:	80 a0 60 00 	cmp  %g1, 0                                    
 200e504:	12 80 00 0f 	bne  200e540 <msdos_format+0xcdc>              
 200e508:	90 07 be 00 	add  %fp, -512, %o0                            
    uint32_t start_sector;                                            
                                                                      
    /*                                                                
     * empty sector: all clusters are free/do not link further on     
     */                                                               
    memset(tmp_sec,0,sizeof(tmp_sec));                                
 200e50c:	92 10 20 00 	clr  %o1                                       
 200e510:	40 00 37 23 	call  201c19c <memset>                         
 200e514:	94 10 22 00 	mov  0x200, %o2                                
                                                                      
    switch(fmt_params.fattype) {                                      
 200e518:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      
 200e51c:	80 a0 60 02 	cmp  %g1, 2                                    
 200e520:	02 80 00 21 	be  200e5a4 <msdos_format+0xd40>               
 200e524:	80 a0 60 04 	cmp  %g1, 4                                    
 200e528:	02 80 00 27 	be  200e5c4 <msdos_format+0xd60>               
 200e52c:	80 a0 60 01 	cmp  %g1, 1                                    
 200e530:	12 80 00 32 	bne  200e5f8 <msdos_format+0xd94>              <== NEVER TAKEN
 200e534:	c2 0f bd dd 	ldub  [ %fp + -547 ], %g1                      
    case FAT_FAT12:                                                   
      /* LSBits of FAT entry 0: media_type */                         
      FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));                
 200e538:	10 80 00 16 	b  200e590 <msdos_format+0xd2c>                
 200e53c:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       
  }                                                                   
  /*                                                                  
   * write volume label to first entry of directory                   
   */                                                                 
  if ((ret_val == 0) && fmt_params.VolLabel_present) {                
    memset(tmp_sec,0,sizeof(tmp_sec));                                
 200e540:	92 10 20 00 	clr  %o1                                       
 200e544:	94 10 22 00 	mov  0x200, %o2                                
 200e548:	40 00 37 15 	call  201c19c <memset>                         
 200e54c:	90 07 be 00 	add  %fp, -512, %o0                            
    memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
 200e550:	92 07 bd e8 	add  %fp, -536, %o1                            
 200e554:	94 10 20 0b 	mov  0xb, %o2                                  
 200e558:	40 00 36 d4 	call  201c0a8 <memcpy>                         
 200e55c:	90 07 be 00 	add  %fp, -512, %o0                            
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
    ret_val = msdos_format_write_sec                                  
 200e560:	d2 07 bd cc 	ld  [ %fp + -564 ], %o1                        
 200e564:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        
   * 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;                  
 200e568:	82 10 20 08 	mov  8, %g1                                    
    ret_val = msdos_format_write_sec                                  
 200e56c:	90 10 00 1c 	mov  %i4, %o0                                  
   * 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;                  
 200e570:	c2 2f be 0b 	stb  %g1, [ %fp + -501 ]                       
    ret_val = msdos_format_write_sec                                  
 200e574:	7f ff fc 35 	call  200d648 <msdos_format_write_sec>         
 200e578:	96 07 be 00 	add  %fp, -512, %o3                            
  /*                                                                  
   * 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) {                                                 
 200e57c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200e580:	12 80 00 49 	bne  200e6a4 <msdos_format+0xe40>              <== NEVER TAKEN
 200e584:	80 a6 20 00 	cmp  %i0, 0                                    
    uint32_t start_sector;                                            
                                                                      
    /*                                                                
     * empty sector: all clusters are free/do not link further on     
     */                                                               
    memset(tmp_sec,0,sizeof(tmp_sec));                                
 200e588:	10 bf ff e1 	b  200e50c <msdos_format+0xca8>                
 200e58c:	90 07 be 00 	add  %fp, -512, %o0                            
    switch(fmt_params.fattype) {                                      
    case FAT_FAT12:                                                   
      /* LSBits of FAT entry 0: media_type */                         
      FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));                
      /* 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)));          
 200e590:	82 10 3f 8f 	mov  -113, %g1                                 
 200e594:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       
      /* MSBits of FAT entry 1: MSBits of EOC */                      
      FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));                   
 200e598:	82 10 3f ff 	mov  -1, %g1                                   
      break;                                                          
 200e59c:	10 80 00 1b 	b  200e608 <msdos_format+0xda4>                
 200e5a0:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       
                                                                      
    case FAT_FAT16:                                                   
      /* FAT entry 0: 0xff00|media_type */                            
      FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);                  
 200e5a4:	c2 0f bd dd 	ldub  [ %fp + -547 ], %g1                      
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
 200e5a8:	84 10 3f f8 	mov  -8, %g2                                   
      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);                  
 200e5ac:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
 200e5b0:	c4 2f be 02 	stb  %g2, [ %fp + -510 ]                       
      break;                                                          
                                                                      
    case FAT_FAT16:                                                   
      /* FAT entry 0: 0xff00|media_type */                            
      FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);                  
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
 200e5b4:	82 10 3f ff 	mov  -1, %g1                                   
 200e5b8:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
      break;                                                          
 200e5bc:	10 80 00 13 	b  200e608 <msdos_format+0xda4>                
 200e5c0:	c2 2f be 03 	stb  %g1, [ %fp + -509 ]                       
                                                                      
    case FAT_FAT32:                                                   
      /* FAT entry 0: 0xffffff00|media_type */                        
      FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);      
 200e5c4:	c2 0f bd dd 	ldub  [ %fp + -547 ], %g1                      
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
 200e5c8:	84 10 3f f8 	mov  -8, %g2                                   
      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);      
 200e5cc:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       
 200e5d0:	82 10 3f ff 	mov  -1, %g1                                   
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
 200e5d4:	c4 2f be 04 	stb  %g2, [ %fp + -508 ]                       
      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);      
 200e5d8:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       
 200e5dc:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       
 200e5e0:	c2 2f be 03 	stb  %g1, [ %fp + -509 ]                       
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
 200e5e4:	c2 2f be 05 	stb  %g1, [ %fp + -507 ]                       
 200e5e8:	c2 2f be 06 	stb  %g1, [ %fp + -506 ]                       
 200e5ec:	82 10 20 0f 	mov  0xf, %g1                                  
      break;                                                          
 200e5f0:	10 80 00 06 	b  200e608 <msdos_format+0xda4>                
 200e5f4:	c2 2f be 07 	stb  %g1, [ %fp + -505 ]                       
                                                                      
    default:                                                          
      ret_val = -1;                                                   
      errno = EINVAL;                                                 
 200e5f8:	40 00 33 ed 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200e5fc:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
 200e600:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
 200e604:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    }                                                                 
    if (fmt_params.fattype == FAT_FAT32) {                            
 200e608:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      
 200e60c:	80 a0 60 04 	cmp  %g1, 4                                    
 200e610:	12 80 00 0a 	bne  200e638 <msdos_format+0xdd4>              
 200e614:	c4 0f bd fc 	ldub  [ %fp + -516 ], %g2                      
      /*                                                              
       * 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);                         
 200e618:	82 10 3f f8 	mov  -8, %g1                                   
 200e61c:	c2 2f be 08 	stb  %g1, [ %fp + -504 ]                       
 200e620:	82 10 3f ff 	mov  -1, %g1                                   
 200e624:	c2 2f be 09 	stb  %g1, [ %fp + -503 ]                       
 200e628:	c2 2f be 0a 	stb  %g1, [ %fp + -502 ]                       
 200e62c:	82 10 20 0f 	mov  0xf, %g1                                  
 200e630:	c2 2f be 0b 	stb  %g1, [ %fp + -501 ]                       
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200e634:	c4 0f bd fc 	ldub  [ %fp + -516 ], %g2                      
       * 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,      
 200e638:	f6 07 bd b4 	ld  [ %fp + -588 ], %i3                        
static uint32_t                                                       
 loc_align_object (const uint32_t sectors,                            
                   const uint32_t clustersize,                        
                   const bool     skip_alignment)                     
{                                                                     
  if (! skip_alignment)                                               
 200e63c:	80 a0 a0 00 	cmp  %g2, 0                                    
 200e640:	12 80 00 06 	bne  200e658 <msdos_format+0xdf4>              
 200e644:	c2 07 bd b8 	ld  [ %fp + -584 ], %g1                        
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
 200e648:	b6 06 c0 01 	add  %i3, %g1, %i3                             
 200e64c:	82 20 00 01 	neg  %g1                                       
 200e650:	b6 06 ff ff 	add  %i3, -1, %i3                              
 200e654:	b6 0e c0 01 	and  %i3, %g1, %i3                             
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
 200e658:	b0 10 00 1d 	mov  %i5, %i0                                  
 200e65c:	10 80 00 0b 	b  200e688 <msdos_format+0xe24>                
 200e660:	ba 10 20 00 	clr  %i5                                       
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
	 i++) {                                                              
      ret_val = msdos_format_write_sec                                
        (fd,                                                          
         start_sector                                                 
         + (i * fmt_params.sectors_per_fat),                          
 200e664:	7f ff cf fb 	call  2002650 <.umul>                          
 200e668:	90 10 00 1d 	mov  %i5, %o0                                  
                                     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                                
 200e66c:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        
        (fd,                                                          
 200e670:	92 02 00 1b 	add  %o0, %i3, %o1                             
                                     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                                
 200e674:	96 07 be 00 	add  %fp, -512, %o3                            
 200e678:	90 10 00 1c 	mov  %i4, %o0                                  
 200e67c:	7f ff fb f3 	call  200d648 <msdos_format_write_sec>         
 200e680:	ba 07 60 01 	inc  %i5                                       
 200e684:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    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);                         
 200e688:	c2 0f bd dc 	ldub  [ %fp + -548 ], %g1                      
    }                                                                 
                                                                      
    start_sector = loc_align_object (fmt_params.rsvd_sector_cnt,      
                                     fmt_params.sectors_per_cluster,  
                                     fmt_params.skip_alignment);      
    for (i = 0;                                                       
 200e68c:	80 a7 40 01 	cmp  %i5, %g1                                  
 200e690:	16 80 00 04 	bge  200e6a0 <msdos_format+0xe3c>              
 200e694:	80 a6 20 00 	cmp  %i0, 0                                    
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
 200e698:	02 bf ff f3 	be  200e664 <msdos_format+0xe00>               <== ALWAYS TAKEN
 200e69c:	d2 07 bd bc 	ld  [ %fp + -580 ], %o1                        
         fmt_params.bytes_per_sector,                                 
         tmp_sec);                                                    
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0 && rqdata != NULL && rqdata->sync_device) {        
 200e6a0:	80 a6 20 00 	cmp  %i0, 0                                    
 200e6a4:	12 80 00 0f 	bne  200e6e0 <msdos_format+0xe7c>              
 200e6a8:	80 a7 3f ff 	cmp  %i4, -1                                   
 200e6ac:	80 8e a0 ff 	btst  0xff, %i2                                
 200e6b0:	02 80 00 0c 	be  200e6e0 <msdos_format+0xe7c>               
 200e6b4:	80 a7 3f ff 	cmp  %i4, -1                                   
 200e6b8:	c2 0e 60 17 	ldub  [ %i1 + 0x17 ], %g1                      
 200e6bc:	80 a0 60 00 	cmp  %g1, 0                                    
 200e6c0:	02 80 00 08 	be  200e6e0 <msdos_format+0xe7c>               
 200e6c4:	80 a7 3f ff 	cmp  %i4, -1                                   
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);                   
}                                                                     
                                                                      
static inline int rtems_disk_fd_sync(int fd)                          
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_SYNCDEV);                              
 200e6c8:	90 10 00 1c 	mov  %i4, %o0                                  
 200e6cc:	13 08 00 10 	sethi  %hi(0x20004000), %o1                    
 200e6d0:	40 00 18 d2 	call  2014a18 <ioctl>                          
 200e6d4:	92 12 62 06 	or  %o1, 0x206, %o1	! 20004206 <RAM_END+0x1dc04206>
 200e6d8:	b0 10 00 08 	mov  %o0, %i0                                  
  /*                                                                  
   * cleanup:                                                         
   * sync and unlock disk                                             
   * free any data structures (not needed now)                        
   */                                                                 
  if (fd != -1) {                                                     
 200e6dc:	80 a7 3f ff 	cmp  %i4, -1                                   
 200e6e0:	02 80 00 40 	be  200e7e0 <msdos_format+0xf7c>               <== NEVER TAKEN
 200e6e4:	01 00 00 00 	nop                                            
    close(fd);                                                        
 200e6e8:	7f ff da 5e 	call  2005060 <close>                          
 200e6ec:	90 10 00 1c 	mov  %i4, %o0                                  
 200e6f0:	81 c7 e0 08 	ret                                            
 200e6f4:	81 e8 00 00 	restore                                        
  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));                           
 200e6f8:	94 10 20 54 	mov  0x54, %o2                                 
 200e6fc:	40 00 36 a8 	call  201c19c <memset>                         
 200e700:	90 07 bd ac 	add  %fp, -596, %o0                            
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);    
 200e704:	90 10 00 1c 	mov  %i4, %o0                                  
 200e708:	37 10 01 10 	sethi  %hi(0x40044000), %i3                    
 200e70c:	94 07 bd ac 	add  %fp, -596, %o2                            
 200e710:	40 00 18 c2 	call  2014a18 <ioctl>                          
 200e714:	92 16 e2 02 	or  %i3, 0x202, %o1                            
   * 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) {                                                 
 200e718:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e71c:	12 bf fd ed 	bne  200ded0 <msdos_format+0x66c>              <== NEVER TAKEN
 200e720:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        
static inline int rtems_disk_fd_get_block_count(                      
  int fd,                                                             
  rtems_blkdev_bnum *block_count                                      
)                                                                     
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);                 
 200e724:	10 bf fc 7f 	b  200d920 <msdos_format+0xbc>                 
 200e728:	90 10 00 1c 	mov  %i4, %o0                                  
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val == 0)                                                   
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
 200e72c:	d6 0f bd dc 	ldub  [ %fp + -548 ], %o3                      
 200e730:	90 10 00 19 	mov  %i1, %o0                                  
 200e734:	92 10 20 02 	mov  2, %o1                                    
 200e738:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200e73c:	7f ff fb ae 	call  200d5f4 <msdos_format_printf>            
 200e740:	94 12 a2 a0 	or  %o2, 0x2a0, %o2	! 202b6a0 <_CPU_Trap_slot_template+0x158>
     * 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) {         
 200e744:	80 a6 60 00 	cmp  %i1, 0                                    
 200e748:	32 bf fc 9e 	bne,a   200d9c0 <msdos_format+0x15c>           
 200e74c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
     * 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;                               
 200e750:	10 bf fc a0 	b  200d9d0 <msdos_format+0x16c>                
 200e754:	84 10 20 20 	mov  0x20, %g2                                 
  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) &&                                           
 200e758:	32 bf fe 4c 	bne,a   200e088 <msdos_format+0x824>           
 200e75c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->VolLabel;                         
      int          cnt;                                               
      from = ""; /* default: make "from" point to empty string */     
 200e760:	10 bf fe 50 	b  200e0a0 <msdos_format+0x83c>                
 200e764:	03 00 80 aa 	sethi  %hi(0x202a800), %g1                     
{                                                                     
  int ret_val = 0;                                                    
  int rc;                                                             
  struct timeval time_value;                                          
                                                                      
  rc = rtems_clock_get_tod_timeval(&time_value);                      
 200e768:	40 00 1c b0 	call  2015a28 <rtems_clock_get_tod_timeval>    
 200e76c:	90 07 be 00 	add  %fp, -512, %o0                            
  if (rc == RTEMS_SUCCESSFUL) {                                       
 200e770:	80 a2 20 00 	cmp  %o0, 0                                    
 200e774:	02 bf fe 63 	be  200e100 <msdos_format+0x89c>               <== NEVER TAKEN
 200e778:	c2 07 be 00 	ld  [ %fp + -512 ], %g1                        
 200e77c:	30 bf fe 64 	b,a   200e10c <msdos_format+0x8a8>             
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > read(fd,buffer,sector_size)) {                            
 200e780:	92 07 be 00 	add  %fp, -512, %o1                            
 200e784:	40 00 19 8f 	call  2014dc0 <read>                           
 200e788:	94 10 00 1d 	mov  %i5, %o2                                  
 200e78c:	80 a2 20 00 	cmp  %o0, 0                                    
 200e790:	16 80 00 08 	bge  200e7b0 <msdos_format+0xf4c>              <== ALWAYS TAKEN
 200e794:	90 10 00 19 	mov  %i1, %o0                                  
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
  {                                                                   
    errno = EINVAL;                                                   
    ret_val = -1;                                                     
 200e798:	10 80 00 04 	b  200e7a8 <msdos_format+0xf44>                <== NOT EXECUTED
 200e79c:	ba 10 3f ff 	mov  -1, %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;                                                       
 200e7a0:	10 bf ff c0 	b  200e6a0 <msdos_format+0xe3c>                <== NOT EXECUTED
 200e7a4:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 200e7a8:	10 bf ff be 	b  200e6a0 <msdos_format+0xe3c>                <== NOT EXECUTED
 200e7ac:	b0 10 00 1d 	mov  %i5, %i0                                  <== 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,       
 200e7b0:	92 10 20 02 	mov  2, %o1                                    
 200e7b4:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200e7b8:	7f ff fb 8f 	call  200d5f4 <msdos_format_printf>            
 200e7bc:	94 12 a2 b8 	or  %o2, 0x2b8, %o2	! 202b6b8 <_CPU_Trap_slot_template+0x170>
{                                                                     
  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) {                        
 200e7c0:	fa 07 bd b0 	ld  [ %fp + -592 ], %i5                        
 200e7c4:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 200e7c8:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
 200e7cc:	80 a7 40 01 	cmp  %i5, %g1                                  
 200e7d0:	18 bf fe 7a 	bgu  200e1b8 <msdos_format+0x954>              
 200e7d4:	b6 10 20 00 	clr  %i3                                       
 200e7d8:	10 bf fe 77 	b  200e1b4 <msdos_format+0x950>                
 200e7dc:	b6 10 00 1d 	mov  %i5, %i3                                  
  if (fd != -1) {                                                     
    close(fd);                                                        
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
 200e7e0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e7e4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200d6a8 <msdos_format_fill_sectors>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
 200d6a8:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
 200d6ac:	7f ff e0 74 	call  200587c <malloc>                         
 200d6b0:	90 10 00 1c 	mov  %i4, %o0                                  
    if (fill_buffer == NULL) {                                        
 200d6b4:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 200d6b8:	12 80 00 07 	bne  200d6d4 <msdos_format_fill_sectors+0x2c>  <== ALWAYS TAKEN
 200d6bc:	92 10 00 1d 	mov  %i5, %o1                                  
      errno = ENOMEM;                                                 
 200d6c0:	40 00 37 bb 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200d6c4:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
 200d6c8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
 200d6cc:	10 80 00 05 	b  200d6e0 <msdos_format_fill_sectors+0x38>    <== NOT EXECUTED
 200d6d0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
      ret_val = -1;                                                   
    }                                                                 
    else {                                                            
      memset(fill_buffer,fill_byte,sector_size);                      
 200d6d4:	94 10 00 1c 	mov  %i4, %o2                                  
 200d6d8:	40 00 3a b1 	call  201c19c <memset>                         
 200d6dc:	ba 10 20 00 	clr  %i5                                       
    }                                                                 
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
 200d6e0:	90 10 00 18 	mov  %i0, %o0                                  
 200d6e4:	92 10 20 02 	mov  2, %o1                                    
 200d6e8:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     
 200d6ec:	7f ff ff c2 	call  200d5f4 <msdos_format_printf>            
 200d6f0:	94 12 a1 58 	or  %o2, 0x158, %o2	! 202b558 <_CPU_Trap_slot_template+0x10>
}                                                                     
                                                                      
/*=========================================================================* \
| Function:                                                                 |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors                                  
 200d6f4:	85 2e e0 02 	sll  %i3, 2, %g2                               
 200d6f8:	83 2e e0 04 	sll  %i3, 4, %g1                               
  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, ".");
 200d6fc:	2b 00 80 ac 	sethi  %hi(0x202b000), %l5                     
}                                                                     
                                                                      
/*=========================================================================* \
| Function:                                                                 |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors                                  
 200d700:	82 00 80 01 	add  %g2, %g1, %g1                             
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
 200d704:	a4 10 20 00 	clr  %l2                                       
}                                                                     
                                                                      
/*=========================================================================* \
| Function:                                                                 |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors                                  
 200d708:	a7 28 60 02 	sll  %g1, 2, %l3                               
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
  char *fill_buffer = NULL;                                           
  uint32_t total_sectors = sector_cnt;                                
  int last_percent = -1;                                              
 200d70c:	a2 10 3f ff 	mov  -1, %l1                                   
}                                                                     
                                                                      
/*=========================================================================* \
| Function:                                                                 |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors                                  
 200d710:	a6 00 40 13 	add  %g1, %l3, %l3                             
 200d714:	a8 06 c0 1a 	add  %i3, %i2, %l4                             
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
 200d718:	10 80 00 15 	b  200d76c <msdos_format_fill_sectors+0xc4>    
 200d71c:	aa 15 63 00 	or  %l5, 0x300, %l5                            
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
 200d720:	7f ff d4 06 	call  2002738 <.udiv>                          
 200d724:	92 10 00 1b 	mov  %i3, %o1                                  
    if (percent != last_percent) {                                    
 200d728:	80 a2 00 11 	cmp  %o0, %l1                                  
 200d72c:	02 80 00 08 	be  200d74c <msdos_format_fill_sectors+0xa4>   
 200d730:	80 8a 20 01 	btst  1, %o0                                   
      if ((percent & 1) == 0)                                         
 200d734:	12 80 00 06 	bne  200d74c <msdos_format_fill_sectors+0xa4>  
 200d738:	a2 10 00 08 	mov  %o0, %l1                                  
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
 200d73c:	90 10 00 18 	mov  %i0, %o0                                  
 200d740:	92 10 20 02 	mov  2, %o1                                    
 200d744:	7f ff ff ac 	call  200d5f4 <msdos_format_printf>            
 200d748:	94 10 00 15 	mov  %l5, %o2                                  
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
 200d74c:	92 10 00 1a 	mov  %i2, %o1                                  
 200d750:	90 10 00 19 	mov  %i1, %o0                                  
 200d754:	94 10 00 1c 	mov  %i4, %o2                                  
 200d758:	96 10 00 10 	mov  %l0, %o3                                  
 200d75c:	7f ff ff bb 	call  200d648 <msdos_format_write_sec>         
 200d760:	b4 06 a0 01 	inc  %i2                                       
 200d764:	a4 04 bf 9c 	add  %l2, -100, %l2                            
 200d768:	ba 10 00 08 	mov  %o0, %i5                                  
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
 200d76c:	80 a5 00 1a 	cmp  %l4, %i2                                  
 200d770:	02 80 00 04 	be  200d780 <msdos_format_fill_sectors+0xd8>   
 200d774:	80 a7 60 00 	cmp  %i5, 0                                    
 200d778:	02 bf ff ea 	be  200d720 <msdos_format_fill_sectors+0x78>   <== ALWAYS TAKEN
 200d77c:	90 04 80 13 	add  %l2, %l3, %o0                             
    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");    
 200d780:	90 10 00 18 	mov  %i0, %o0                                  
 200d784:	92 10 20 02 	mov  2, %o1                                    
 200d788:	15 00 80 aa 	sethi  %hi(0x202a800), %o2                     
 200d78c:	7f ff ff 9a 	call  200d5f4 <msdos_format_printf>            
 200d790:	94 12 a3 48 	or  %o2, 0x348, %o2	! 202ab48 <__clz_tab+0x478>
                                                                      
  if (ret_val)                                                        
 200d794:	80 a7 60 00 	cmp  %i5, 0                                    
 200d798:	02 80 00 09 	be  200d7bc <msdos_format_fill_sectors+0x114>  <== ALWAYS TAKEN
 200d79c:	80 a4 20 00 	cmp  %l0, 0                                    
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,           
 200d7a0:	15 00 80 ad 	sethi  %hi(0x202b400), %o2                     <== NOT EXECUTED
 200d7a4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200d7a8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 200d7ac:	94 12 a1 68 	or  %o2, 0x168, %o2                            <== NOT EXECUTED
 200d7b0:	7f ff ff 91 	call  200d5f4 <msdos_format_printf>            <== NOT EXECUTED
 200d7b4:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
                         "filling error on sector: %d\n", start_sector);
                                                                      
  /*                                                                  
   * cleanup                                                          
   */                                                                 
  if (fill_buffer != NULL) {                                          
 200d7b8:	80 a4 20 00 	cmp  %l0, 0                                    <== NOT EXECUTED
 200d7bc:	02 80 00 04 	be  200d7cc <msdos_format_fill_sectors+0x124>  <== NEVER TAKEN
 200d7c0:	01 00 00 00 	nop                                            
    free(fill_buffer);                                                
 200d7c4:	7f ff de e4 	call  2005354 <free>                           
 200d7c8:	90 10 00 10 	mov  %l0, %o0                                  
    fill_buffer = NULL;                                               
  }                                                                   
  return ret_val;                                                     
}                                                                     
 200d7cc:	81 c7 e0 08 	ret                                            
 200d7d0:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

0200d5f4 <msdos_format_printf>: */ static void msdos_format_printf (const msdos_format_request_param_t *rqdata, int info_level, const char *format, ...) {
 200d5f4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  va_list args;                                                       
  va_start (args, format);                                            
 200d5f8:	94 07 a0 50 	add  %fp, 0x50, %o2                            
 200d5fc:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
 200d600:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
 200d604:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
  if (rqdata != NULL && rqdata->info_level >= info_level)             
 200d608:	80 a6 20 00 	cmp  %i0, 0                                    
 200d60c:	02 80 00 0d 	be  200d640 <msdos_format_printf+0x4c>         
 200d610:	d4 27 bf fc 	st  %o2, [ %fp + -4 ]                          
 200d614:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
 200d618:	80 a0 40 19 	cmp  %g1, %i1                                  
 200d61c:	06 80 00 09 	bl  200d640 <msdos_format_printf+0x4c>         <== ALWAYS TAKEN
 200d620:	3b 00 80 b4 	sethi  %hi(0x202d000), %i5                     
  {                                                                   
    vfprintf (stdout, format, args);                                  
 200d624:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1	! 202d010 <_impure_ptr><== NOT EXECUTED
 200d628:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 200d62c:	40 00 5a 88 	call  202404c <vfprintf>                       <== NOT EXECUTED
 200d630:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    fflush (stdout);                                                  
 200d634:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
 200d638:	40 00 38 e0 	call  201b9b8 <fflush>                         <== NOT EXECUTED
 200d63c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
 200d640:	81 c7 e0 08 	ret                                            
 200d644:	81 e8 00 00 	restore                                        
                                                                      

0200d648 <msdos_format_write_sec>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
 200d648:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
 200d64c:	94 10 20 00 	clr  %o2                                       
 200d650:	96 10 00 1a 	mov  %i2, %o3                                  
 200d654:	90 10 20 00 	clr  %o0                                       
 200d658:	7f ff d2 e1 	call  20021dc <__muldi3>                       
 200d65c:	92 10 00 19 	mov  %i1, %o1                                  
 200d660:	84 10 00 08 	mov  %o0, %g2                                  
 200d664:	86 10 00 09 	mov  %o1, %g3                                  
 200d668:	90 10 00 18 	mov  %i0, %o0                                  
 200d66c:	92 10 00 02 	mov  %g2, %o1                                  
 200d670:	94 10 00 03 	mov  %g3, %o2                                  
 200d674:	40 00 1d 0a 	call  2014a9c <lseek>                          
 200d678:	96 10 20 00 	clr  %o3                                       
 200d67c:	80 a2 20 00 	cmp  %o0, 0                                    
 200d680:	16 80 00 04 	bge  200d690 <msdos_format_write_sec+0x48>     <== ALWAYS TAKEN
 200d684:	90 10 00 18 	mov  %i0, %o0                                  
 200d688:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200d68c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > write(fd,buffer,sector_size)) {                           
 200d690:	92 10 00 1b 	mov  %i3, %o1                                  
 200d694:	7f ff ee 9b 	call  2009100 <write>                          
 200d698:	94 10 00 1a 	mov  %i2, %o2                                  
 200d69c:	b1 3a 20 1f 	sra  %o0, 0x1f, %i0                            
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
 200d6a0:	81 c7 e0 08 	ret                                            
 200d6a4:	81 e8 00 00 	restore                                        
                                                                      

02018e10 <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 ) {
 2018e10:	9d e3 bf 50 	save  %sp, -176, %sp                           
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
 2018e14:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
    fat_file_fd_t   *fat_fd = NULL;                                   
 2018e18:	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);              
 2018e1c:	90 10 00 1c 	mov  %i4, %o0                                  
 2018e20:	92 10 00 1a 	mov  %i2, %o1                                  
 2018e24:	7f ff e4 d9 	call  2012188 <fat_file_open>                  
 2018e28:	94 07 bf bc 	add  %fp, -68, %o2                             
    if (rc != RC_OK)                                                  
 2018e2c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2018e30:	32 80 00 a5 	bne,a   20190c4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NEVER TAKEN
 2018e34:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
 2018e38:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
 2018e3c:	03 00 08 00 	sethi  %hi(0x200000), %g1                      
     */                                                               
    rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);              
    if (rc != RC_OK)                                                  
        return rc;                                                    
                                                                      
    fat_fd->cln = cln;                                                
 2018e40:	f2 22 60 1c 	st  %i1, [ %o1 + 0x1c ]                        
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
 2018e44:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
 2018e48:	c2 22 60 14 	st  %g1, [ %o1 + 0x14 ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
 2018e4c:	c0 22 60 34 	clr  [ %o1 + 0x34 ]                            
    fat_fd->map.disk_cln = fat_fd->cln;                               
 2018e50:	f2 22 60 38 	st  %i1, [ %o1 + 0x38 ]                        
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
 2018e54:	7f ff e7 7a 	call  2012c3c <fat_file_size>                  
 2018e58:	90 10 00 1c 	mov  %i4, %o0                                  
    if (rc != RC_OK)                                                  
 2018e5c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2018e60:	22 80 00 04 	be,a   2018e70 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x60><== ALWAYS TAKEN
 2018e64:	ba 07 bf c0 	add  %fp, -64, %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);                        
 2018e68:	10 80 00 19 	b  2018ecc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xbc><== NOT EXECUTED
 2018e6c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    /* find "." node in opened directory */                           
    memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);           
 2018e70:	92 10 20 00 	clr  %o1                                       
 2018e74:	90 10 00 1d 	mov  %i5, %o0                                  
 2018e78:	40 00 0c c9 	call  201c19c <memset>                         
 2018e7c:	94 10 20 20 	mov  0x20, %o2                                 
    msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);      
 2018e80:	94 10 00 1d 	mov  %i5, %o2                                  
 2018e84:	33 00 80 ac 	sethi  %hi(0x202b000), %i1                     
 2018e88:	92 10 20 01 	mov  1, %o1                                    
 2018e8c:	96 10 20 0b 	mov  0xb, %o3                                  
 2018e90:	7f ff fb 7a 	call  2017c78 <msdos_long_to_short>            
 2018e94:	90 16 63 00 	or  %i1, 0x300, %o0                            
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1, 
 2018e98:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
 2018e9c:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
 2018ea0:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
 2018ea4:	90 10 00 18 	mov  %i0, %o0                                  
 2018ea8:	94 10 20 00 	clr  %o2                                       
 2018eac:	96 16 63 00 	or  %i1, 0x300, %o3                            
 2018eb0:	98 10 20 01 	mov  1, %o4                                    
 2018eb4:	7f ff fd 1b 	call  2018320 <msdos_find_name_in_fat_file>    
 2018eb8:	9a 10 20 01 	mov  1, %o5                                    
                                     MSDOS_NAME_SHORT, dir_pos, dot_node);
                                                                      
    if (rc != RC_OK)                                                  
 2018ebc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2018ec0:	22 80 00 05 	be,a   2018ed4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc4><== ALWAYS TAKEN
 2018ec4:	ba 07 bf e0 	add  %fp, -32, %i5                             
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
 2018ec8:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 2018ecc:	10 80 00 77 	b  20190a8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
 2018ed0:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         <== NOT EXECUTED
        return rc;                                                    
    }                                                                 
                                                                      
    /* find ".." node in opened directory */                          
    memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);        
 2018ed4:	92 10 20 00 	clr  %o1                                       
 2018ed8:	90 10 00 1d 	mov  %i5, %o0                                  
 2018edc:	40 00 0c b0 	call  201c19c <memset>                         
 2018ee0:	94 10 20 20 	mov  0x20, %o2                                 
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
 2018ee4:	94 10 00 1d 	mov  %i5, %o2                                  
 2018ee8:	33 00 80 ae 	sethi  %hi(0x202b800), %i1                     
 2018eec:	92 10 20 02 	mov  2, %o1                                    
 2018ef0:	96 10 20 0b 	mov  0xb, %o3                                  
 2018ef4:	7f ff fb 61 	call  2017c78 <msdos_long_to_short>            
 2018ef8:	90 16 61 d8 	or  %i1, 0x1d8, %o0                            
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
 2018efc:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
 2018f00:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
 2018f04:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
 2018f08:	90 10 00 18 	mov  %i0, %o0                                  
 2018f0c:	94 10 20 00 	clr  %o2                                       
 2018f10:	96 16 61 d8 	or  %i1, 0x1d8, %o3                            
 2018f14:	98 10 20 02 	mov  2, %o4                                    
 2018f18:	7f ff fd 02 	call  2018320 <msdos_find_name_in_fat_file>    
 2018f1c:	9a 10 20 01 	mov  1, %o5                                    
                                     MSDOS_NAME_SHORT, dir_pos,       
                                     dotdot_node);                    
                                                                      
    if (rc != RC_OK)                                                  
 2018f20:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2018f24:	02 80 00 04 	be  2018f34 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x124><== ALWAYS TAKEN
 2018f28:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
    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);                        
 2018f2c:	10 80 00 5f 	b  20190a8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
 2018f30:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
 2018f34:	e0 17 bf da 	lduh  [ %fp + -38 ], %l0                       
 2018f38:	e2 17 bf d4 	lduh  [ %fp + -44 ], %l1                       
                                                                      
    /* close fat-file corresponded to ".." directory */               
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
 2018f3c:	7f ff e5 a9 	call  20125e0 <fat_file_close>                 
 2018f40:	90 10 00 1c 	mov  %i4, %o0                                  
    if ( rc != RC_OK )                                                
 2018f44:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2018f48:	12 80 00 5e 	bne  20190c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
 2018f4c:	c2 17 bf f4 	lduh  [ %fp + -12 ], %g1                       
        return rc;                                                    
                                                                      
    if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)               
 2018f50:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2018f54:	85 30 60 18 	srl  %g1, 0x18, %g2                            
 2018f58:	87 30 60 08 	srl  %g1, 8, %g3                               
 2018f5c:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 2018f60:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
 2018f64:	86 08 c0 01 	and  %g3, %g1, %g3                             
 2018f68:	86 10 80 03 	or  %g2, %g3, %g3                              
 2018f6c:	c4 17 bf fa 	lduh  [ %fp + -6 ], %g2                        
 2018f70:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 2018f74:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2018f78:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
 2018f7c:	85 30 a0 08 	srl  %g2, 8, %g2                               
 2018f80:	82 08 80 01 	and  %g2, %g1, %g1                             
 2018f84:	82 11 00 01 	or  %g4, %g1, %g1                              
 2018f88:	80 90 c0 01 	orcc  %g3, %g1, %g0                            
 2018f8c:	12 80 00 08 	bne  2018fac <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x19c><== ALWAYS TAKEN
 2018f90:	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;                           
 2018f94:	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;                                             
 2018f98:	c0 26 a0 04 	clr  [ %i2 + 4 ]                               <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
 2018f9c:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
 2018fa0:	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;                 
 2018fa4:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2018fa8:	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);              
 2018fac:	92 10 00 1a 	mov  %i2, %o1                                  
 2018fb0:	7f ff e4 76 	call  2012188 <fat_file_open>                  
 2018fb4:	94 07 bf bc 	add  %fp, -68, %o2                             
    if (rc != RC_OK)                                                  
 2018fb8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2018fbc:	12 80 00 41 	bne  20190c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
 2018fc0:	c2 17 bf f4 	lduh  [ %fp + -12 ], %g1                       
        return rc;                                                    
                                                                      
    if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)                
 2018fc4:	33 00 00 3f 	sethi  %hi(0xfc00), %i1                        
 2018fc8:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2018fcc:	b2 16 63 ff 	or  %i1, 0x3ff, %i1                            
 2018fd0:	bb 30 60 18 	srl  %g1, 0x18, %i5                            
 2018fd4:	83 30 60 08 	srl  %g1, 8, %g1                               
 2018fd8:	82 08 40 19 	and  %g1, %i1, %g1                             
 2018fdc:	ba 17 40 01 	or  %i5, %g1, %i5                              
 2018fe0:	c2 17 bf fa 	lduh  [ %fp + -6 ], %g1                        
 2018fe4:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
 2018fe8:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2018fec:	89 30 60 18 	srl  %g1, 0x18, %g4                            
 2018ff0:	83 30 60 08 	srl  %g1, 8, %g1                               
 2018ff4:	b2 08 40 19 	and  %g1, %i1, %i1                             
 2018ff8:	88 11 00 19 	or  %g4, %i1, %g4                              
 2018ffc:	88 97 40 04 	orcc  %i5, %g4, %g4                            
 2019000:	12 80 00 05 	bne  2019014 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204><== ALWAYS TAKEN
 2019004:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
        fat_fd->cln = fs_info->fat.vol.rdir_cl;                       
 2019008:	c2 07 20 3c 	ld  [ %i4 + 0x3c ], %g1                        <== NOT EXECUTED
 201900c:	10 80 00 03 	b  2019018 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
 2019010:	c2 22 60 1c 	st  %g1, [ %o1 + 0x1c ]                        <== NOT EXECUTED
    else                                                              
        fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);         
 2019014:	c8 22 60 1c 	st  %g4, [ %o1 + 0x1c ]                        
                                                                      
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
 2019018:	03 00 08 00 	sethi  %hi(0x200000), %g1                      
 201901c:	c2 22 60 14 	st  %g1, [ %o1 + 0x14 ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
 2019020:	c2 02 60 1c 	ld  [ %o1 + 0x1c ], %g1                        
    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;                            
 2019024:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
 2019028:	c0 22 60 34 	clr  [ %o1 + 0x34 ]                            
    fat_fd->map.disk_cln = fat_fd->cln;                               
 201902c:	c2 22 60 38 	st  %g1, [ %o1 + 0x38 ]                        
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
 2019030:	7f ff e7 03 	call  2012c3c <fat_file_size>                  
 2019034:	90 10 00 1c 	mov  %i4, %o0                                  
    if (rc != RC_OK)                                                  
 2019038:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201903c:	02 80 00 04 	be  201904c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x23c><== ALWAYS TAKEN
 2019040:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
 2019044:	10 80 00 19 	b  20190a8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
 2019048:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
 201904c:	87 2c 60 10 	sll  %l1, 0x10, %g3                            
 2019050:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
 2019054:	95 30 e0 18 	srl  %g3, 0x18, %o2                            
 2019058:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
 201905c:	87 30 e0 08 	srl  %g3, 8, %g3                               
 2019060:	86 08 c0 01 	and  %g3, %g1, %g3                             
 2019064:	85 2c 20 10 	sll  %l0, 0x10, %g2                            
 2019068:	94 12 80 03 	or  %o2, %g3, %o2                              
 201906c:	87 30 a0 18 	srl  %g2, 0x18, %g3                            
 2019070:	85 30 a0 08 	srl  %g2, 8, %g2                               
 2019074:	82 08 80 01 	and  %g2, %g1, %g1                             
 2019078:	82 10 c0 01 	or  %g3, %g1, %g1                              
 201907c:	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,
 2019080:	90 10 00 18 	mov  %i0, %o0                                  
 2019084:	94 12 80 01 	or  %o2, %g1, %o2                              
 2019088:	96 10 00 1a 	mov  %i2, %o3                                  
 201908c:	7f ff ff 00 	call  2018c8c <msdos_find_node_by_cluster_num_in_fat_file>
 2019090:	98 10 00 1b 	mov  %i3, %o4                                  
 2019094:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
 2019098:	ba 10 00 08 	mov  %o0, %i5                                  
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
 201909c:	80 a7 60 00 	cmp  %i5, 0                                    
 20190a0:	02 80 00 05 	be  20190b4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a4><== ALWAYS TAKEN
 20190a4:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
 20190a8:	7f ff e5 4e 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 20190ac:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 20190b0:	30 80 00 05 	b,a   20190c4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NOT EXECUTED
        return rc;                                                    
    }                                                                 
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
 20190b4:	7f ff e5 4b 	call  20125e0 <fat_file_close>                 
 20190b8:	01 00 00 00 	nop                                            
 20190bc:	ba 10 00 08 	mov  %o0, %i5                                  
    return rc;                                                        
}                                                                     
 20190c0:	b0 10 00 1d 	mov  %i5, %i0                                  
 20190c4:	81 c7 e0 08 	ret                                            
 20190c8:	81 e8 00 00 	restore                                        
                                                                      

020190cc <msdos_get_name_node>: int name_len, msdos_name_type_t name_type, fat_dir_pos_t *dir_pos, char *name_dir_entry ) {
 20190cc:	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,    
 20190d0:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
 20190d4:	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            
    )                                                                 
{                                                                     
 20190d8:	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,    
 20190dc:	9a 10 00 1c 	mov  %i4, %o5                                  
 20190e0:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
 20190e4:	e0 23 a0 60 	st  %l0, [ %sp + 0x60 ]                        
 20190e8:	94 10 00 19 	mov  %i1, %o2                                  
 20190ec:	96 10 00 1a 	mov  %i2, %o3                                  
 20190f0:	7f ff fc 8c 	call  2018320 <msdos_find_name_in_fat_file>    
 20190f4:	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))            
 20190f8:	03 00 00 1f 	sethi  %hi(0x7c00), %g1                        
 20190fc:	82 10 61 01 	or  %g1, 0x101, %g1	! 7d01 <PROM_START+0x7d01> 
 2019100:	80 a2 00 01 	cmp  %o0, %g1                                  
 2019104:	02 80 00 05 	be  2019118 <msdos_get_name_node+0x4c>         
 2019108:	b8 10 00 08 	mov  %o0, %i4                                  
 201910c:	80 a2 20 00 	cmp  %o0, 0                                    
 2019110:	12 80 00 2d 	bne  20191c4 <msdos_get_name_node+0xf8>        
 2019114:	01 00 00 00 	nop                                            
        return rc;                                                    
                                                                      
    if (!create_node)                                                 
 2019118:	80 a6 60 00 	cmp  %i1, 0                                    
 201911c:	12 80 00 2a 	bne  20191c4 <msdos_get_name_node+0xf8>        
 2019120:	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)                           
 2019124:	82 10 61 01 	or  %g1, 0x101, %g1	! 7d01 <PROM_START+0x7d01> 
 2019128:	80 a7 00 01 	cmp  %i4, %g1                                  
 201912c:	02 80 00 26 	be  20191c4 <msdos_get_name_node+0xf8>         
 2019130:	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)                                              
 2019134:	12 80 00 24 	bne  20191c4 <msdos_get_name_node+0xf8>        <== NEVER TAKEN
 2019138:	90 10 00 1a 	mov  %i2, %o0                                  
        {                                                             
            if (strncmp(name, "..", 2) == 0)                          
 201913c:	13 00 80 ae 	sethi  %hi(0x202b800), %o1                     
 2019140:	94 10 20 02 	mov  2, %o2                                    
 2019144:	40 00 12 56 	call  201da9c <strncmp>                        
 2019148:	92 12 61 d8 	or  %o1, 0x1d8, %o1                            
 201914c:	80 a2 20 00 	cmp  %o0, 0                                    
 2019150:	12 80 00 1d 	bne  20191c4 <msdos_get_name_node+0xf8>        
 2019154:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
            {                                                         
                dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
 2019158:	c6 14 20 1a 	lduh  [ %l0 + 0x1a ], %g3                      
 201915c:	c8 14 20 14 	lduh  [ %l0 + 0x14 ], %g4                      
 2019160:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 2019164:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 2019168:	83 30 e0 18 	srl  %g3, 0x18, %g1                            
 201916c:	b3 31 20 18 	srl  %g4, 0x18, %i1                            
 2019170:	89 31 20 08 	srl  %g4, 8, %g4                               
 2019174:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
 2019178:	87 30 e0 08 	srl  %g3, 8, %g3                               
 201917c:	88 09 00 02 	and  %g4, %g2, %g4                             
 2019180:	84 08 c0 02 	and  %g3, %g2, %g2                             
 2019184:	b2 16 40 04 	or  %i1, %g4, %i1                              
 2019188:	82 10 40 02 	or  %g1, %g2, %g1                              
 201918c:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
                                                                      
                /* are we right under root dir ? */                   
                if (dotdot_cln == 0)                                  
 2019190:	b2 96 40 01 	orcc  %i1, %g1, %i1                            
 2019194:	12 80 00 08 	bne  20191b4 <msdos_get_name_node+0xe8>        
 2019198:	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;                                             
 201919c:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
 20191a0:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
 20191a4:	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;     
 20191a8:	82 10 20 01 	mov  1, %g1                                    
 20191ac:	10 80 00 06 	b  20191c4 <msdos_get_name_node+0xf8>          
 20191b0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                }                                                     
                else                                                  
                {                                                     
                    rc =                                              
 20191b4:	f0 06 20 14 	ld  [ %i0 + 0x14 ], %i0                        
 20191b8:	b4 10 00 1d 	mov  %i5, %i2                                  
 20191bc:	7f ff ff 15 	call  2018e10 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
 20191c0:	97 e8 00 10 	restore  %g0, %l0, %o3                         
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
 20191c4:	81 c7 e0 08 	ret                                            
 20191c8:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                                                                      

0200e87c <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 ) {
 200e87c:	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));  
 200e880:	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;                                 
 200e884:	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));  
 200e888:	7f ff d9 df 	call  2005004 <calloc>                         
 200e88c:	92 10 20 a4 	mov  0xa4, %o1                                 
    if (!fs_info)                                                     
 200e890:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e894:	32 80 00 03 	bne,a   200e8a0 <msdos_initialize_support+0x24><== ALWAYS TAKEN
 200e898:	d2 06 20 38 	ld  [ %i0 + 0x38 ], %o1                        
 200e89c:	30 80 00 45 	b,a   200e9b0 <msdos_initialize_support+0x134> <== NOT EXECUTED
        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);     
 200e8a0:	40 00 12 b1 	call  2013364 <fat_init_volume_info>           
 200e8a4:	fa 26 20 08 	st  %i5, [ %i0 + 8 ]                           
    if (rc != RC_OK)                                                  
 200e8a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 200e8ac:	12 80 00 12 	bne  200e8f4 <msdos_initialize_support+0x78>   <== NEVER TAKEN
 200e8b0:	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;                           
 200e8b4:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
 200e8b8:	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;                     
 200e8bc:	82 10 20 01 	mov  1, %g1                                    
    {                                                                 
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    fs_info->file_handlers      = file_handlers;                      
 200e8c0:	f4 27 60 98 	st  %i2, [ %i5 + 0x98 ]                        
    fs_info->directory_handlers = directory_handlers;                 
 200e8c4:	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;                                             
 200e8c8:	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;                     
 200e8cc:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
    rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);            
 200e8d0:	90 10 00 1d 	mov  %i5, %o0                                  
 200e8d4:	92 07 bf f0 	add  %fp, -16, %o1                             
 200e8d8:	40 00 0e 2c 	call  2012188 <fat_file_open>                  
 200e8dc:	94 07 bf ec 	add  %fp, -20, %o2                             
    if (rc != RC_OK)                                                  
 200e8e0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 200e8e4:	02 80 00 08 	be  200e904 <msdos_initialize_support+0x88>    <== ALWAYS TAKEN
 200e8e8:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         
    {                                                                 
        fat_shutdown_drive(&fs_info->fat);                            
 200e8ec:	40 00 14 c2 	call  2013bf4 <fat_shutdown_drive>             <== NOT EXECUTED
 200e8f0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info);                                                
 200e8f4:	7f ff da 98 	call  2005354 <free>                           <== NOT EXECUTED
 200e8f8:	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;                                                        
}                                                                     
 200e8fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e900:	91 e8 00 1c 	restore  %g0, %i4, %o0                         <== NOT EXECUTED
        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;                        
 200e904:	03 00 08 00 	sethi  %hi(0x200000), %g1                      
 200e908:	c2 22 60 14 	st  %g1, [ %o1 + 0x14 ]                        
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
 200e90c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    /* again: unfortunately "fat-file" is just almost fat file :( */  
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
 200e910:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
 200e914:	c2 22 60 1c 	st  %g1, [ %o1 + 0x1c ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
 200e918:	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 )                                           
 200e91c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e920:	12 80 00 09 	bne  200e944 <msdos_initialize_support+0xc8>   
 200e924:	c2 22 60 38 	st  %g1, [ %o1 + 0x38 ]                        
    {                                                                 
        fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;           
 200e928:	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                                :
 200e92c:	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) ?
 200e930:	80 a2 00 01 	cmp  %o0, %g1                                  
 200e934:	1a 80 00 13 	bcc  200e980 <msdos_initialize_support+0x104>  
 200e938:	c2 22 60 18 	st  %g1, [ %o1 + 0x18 ]                        
 200e93c:	10 80 00 11 	b  200e980 <msdos_initialize_support+0x104>    
 200e940:	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);                    
 200e944:	40 00 10 be 	call  2012c3c <fat_file_size>                  
 200e948:	90 10 00 1d 	mov  %i5, %o0                                  
        if ( rc != RC_OK )                                            
 200e94c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 200e950:	22 80 00 0c 	be,a   200e980 <msdos_initialize_support+0x104><== ALWAYS TAKEN
 200e954:	d0 17 60 06 	lduh  [ %i5 + 6 ], %o0                         
        {                                                             
            fat_file_close(&fs_info->fat, fat_fd);                    
 200e958:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         <== NOT EXECUTED
 200e95c:	40 00 0f 21 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 200e960:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            fat_shutdown_drive(&fs_info->fat);                        
 200e964:	40 00 14 a4 	call  2013bf4 <fat_shutdown_drive>             <== NOT EXECUTED
 200e968:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            free(fs_info);                                            
 200e96c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 200e970:	7f ff da 79 	call  2005354 <free>                           <== NOT EXECUTED
 200e974:	b8 10 00 1a 	mov  %i2, %i4                                  <== 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;                                                        
}                                                                     
 200e978:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e97c:	91 e8 00 1c 	restore  %g0, %i4, %o0                         <== NOT EXECUTED
            return rc;                                                
        }                                                             
        cl_buf_size = fs_info->fat.vol.bpc;                           
    }                                                                 
                                                                      
    fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));   
 200e980:	7f ff d9 a1 	call  2005004 <calloc>                         
 200e984:	92 10 20 01 	mov  1, %o1                                    
    if (fs_info->cl_buf == NULL)                                      
 200e988:	80 a2 20 00 	cmp  %o0, 0                                    
 200e98c:	12 80 00 0f 	bne  200e9c8 <msdos_initialize_support+0x14c>  <== ALWAYS TAKEN
 200e990:	d0 27 60 a0 	st  %o0, [ %i5 + 0xa0 ]                        
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
 200e994:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         <== NOT EXECUTED
 200e998:	40 00 0f 12 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 200e99c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        fat_shutdown_drive(&fs_info->fat);                            
 200e9a0:	40 00 14 95 	call  2013bf4 <fat_shutdown_drive>             <== NOT EXECUTED
 200e9a4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info);                                                
 200e9a8:	7f ff da 6b 	call  2005354 <free>                           <== NOT EXECUTED
 200e9ac:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
 200e9b0:	40 00 32 ff 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200e9b4:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200e9b8:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
 200e9bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 200e9c0:	10 80 00 1b 	b  200ea2c <msdos_initialize_support+0x1b0>    <== NOT EXECUTED
 200e9c4:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
    }                                                                 
                                                                      
    sc = rtems_semaphore_create(3,                                    
 200e9c8:	92 10 20 01 	mov  1, %o1                                    
 200e9cc:	90 10 20 03 	mov  3, %o0                                    
 200e9d0:	94 10 20 10 	mov  0x10, %o2                                 
 200e9d4:	96 10 20 00 	clr  %o3                                       
 200e9d8:	7f ff eb 0e 	call  2009610 <rtems_semaphore_create>         
 200e9dc:	98 07 60 9c 	add  %i5, 0x9c, %o4                            
                                1,                                    
                                RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,  
                                0,                                    
                                &fs_info->vol_sema);                  
    if (sc != RTEMS_SUCCESSFUL)                                       
 200e9e0:	80 a2 20 00 	cmp  %o0, 0                                    
 200e9e4:	02 80 00 0e 	be  200ea1c <msdos_initialize_support+0x1a0>   <== ALWAYS TAKEN
 200e9e8:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
 200e9ec:	40 00 0e fd 	call  20125e0 <fat_file_close>                 <== NOT EXECUTED
 200e9f0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        fat_shutdown_drive(&fs_info->fat);                            
 200e9f4:	40 00 14 80 	call  2013bf4 <fat_shutdown_drive>             <== NOT EXECUTED
 200e9f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info->cl_buf);                                        
 200e9fc:	7f ff da 56 	call  2005354 <free>                           <== NOT EXECUTED
 200ea00:	d0 07 60 a0 	ld  [ %i5 + 0xa0 ], %o0                        <== NOT EXECUTED
        free(fs_info);                                                
 200ea04:	7f ff da 54 	call  2005354 <free>                           <== NOT EXECUTED
 200ea08:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
 200ea0c:	40 00 32 e8 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200ea10:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200ea14:	10 bf ff ea 	b  200e9bc <msdos_initialize_support+0x140>    <== NOT EXECUTED
 200ea18:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
    }                                                                 
                                                                      
    temp_mt_entry->mt_fs_root->location.node_access = fat_fd;         
 200ea1c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 200ea20:	d2 20 60 08 	st  %o1, [ %g1 + 8 ]                           
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
 200ea24:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
    temp_mt_entry->ops = op_table;                                    
 200ea28:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
                                                                      
    return rc;                                                        
}                                                                     
 200ea2c:	b0 10 00 1c 	mov  %i4, %i0                                  
 200ea30:	81 c7 e0 08 	ret                                            
 200ea34:	81 e8 00 00 	restore                                        
                                                                      

0200e848 <msdos_lock>: .rename_h = msdos_rename, .statvfs_h = rtems_filesystem_default_statvfs }; void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry) {
 200e848:	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,                                                
 200e84c:	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(                      
 200e850:	92 10 20 00 	clr  %o1                                       
 200e854:	d0 00 60 9c 	ld  [ %g1 + 0x9c ], %o0                        
 200e858:	7f ff ec 0b 	call  2009884 <rtems_semaphore_obtain>         
 200e85c:	94 10 20 00 	clr  %o2                                       
    fs_info->vol_sema,                                                
    RTEMS_WAIT,                                                       
    RTEMS_NO_TIMEOUT                                                  
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 200e860:	80 a2 20 00 	cmp  %o0, 0                                    
 200e864:	02 80 00 04 	be  200e874 <msdos_lock+0x2c>                  <== ALWAYS TAKEN
 200e868:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
    rtems_fatal_error_occurred(0xdeadbeef);                           
 200e86c:	7f ff ed f1 	call  200a030 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 200e870:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
 200e874:	81 c7 e0 08 	ret                                            
 200e878:	81 e8 00 00 	restore                                        
                                                                      

02017c78 <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) {
 2017c78:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int               i;                                              
                                                                      
    /*                                                                
     * Fill with spaces. This is how a short directory entry is padded.
     */                                                               
    memset (sfn, ' ', sfn_len);                                       
 2017c7c:	92 10 20 20 	mov  0x20, %o1                                 
 2017c80:	90 10 00 1a 	mov  %i2, %o0                                  
 2017c84:	40 00 11 46 	call  201c19c <memset>                         
 2017c88:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
 2017c8c:	c2 4e 00 00 	ldsb  [ %i0 ], %g1                             
 2017c90:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
 2017c94:	12 80 00 23 	bne  2017d20 <msdos_long_to_short+0xa8>        
 2017c98:	84 10 20 00 	clr  %g2                                       
 2017c9c:	80 a6 60 01 	cmp  %i1, 1                                    
 2017ca0:	32 80 00 04 	bne,a   2017cb0 <msdos_long_to_short+0x38>     
 2017ca4:	c2 4e 20 01 	ldsb  [ %i0 + 1 ], %g1                         
        return MSDOS_NAME_SHORT;                                      
    }                                                                 
                                                                      
    if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))         
    {                                                                 
        sfn[0] = sfn[1] = '.';                                        
 2017ca8:	10 80 00 0a 	b  2017cd0 <msdos_long_to_short+0x58>          
 2017cac:	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))         
 2017cb0:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
 2017cb4:	12 80 00 1c 	bne  2017d24 <msdos_long_to_short+0xac>        <== NEVER TAKEN
 2017cb8:	80 a0 80 19 	cmp  %g2, %i1                                  
 2017cbc:	80 a6 60 02 	cmp  %i1, 2                                    
 2017cc0:	12 80 00 19 	bne  2017d24 <msdos_long_to_short+0xac>        <== NEVER TAKEN
 2017cc4:	80 a0 80 19 	cmp  %g2, %i1                                  
    {                                                                 
        sfn[0] = sfn[1] = '.';                                        
 2017cc8:	c2 2e a0 01 	stb  %g1, [ %i2 + 1 ]                          
 2017ccc:	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;                                      
 2017cd0:	10 80 00 72 	b  2017e98 <msdos_long_to_short+0x220>         
 2017cd4:	82 10 20 01 	mov  1, %g1                                    
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
 2017cd8:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
 2017cdc:	22 80 00 11 	be,a   2017d20 <msdos_long_to_short+0xa8>      <== NEVER TAKEN
 2017ce0:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
 2017ce4:	80 a0 60 20 	cmp  %g1, 0x20                                 
 2017ce8:	22 80 00 0e 	be,a   2017d20 <msdos_long_to_short+0xa8>      
 2017cec:	84 00 a0 01 	inc  %g2                                       
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
 2017cf0:	03 00 80 b4 	sethi  %hi(0x202d000), %g1                     
 2017cf4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1	! 202d008 <__ctype_ptr__> 
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
 2017cf8:	2d 00 80 af 	sethi  %hi(0x202bc00), %l6                     
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
 2017cfc:	2f 00 80 af 	sethi  %hi(0x202bc00), %l7                     
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
 2017d00:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
 2017d04:	b8 10 20 00 	clr  %i4                                       
 2017d08:	a2 10 3f ff 	mov  -1, %l1                                   
 2017d0c:	a4 10 20 00 	clr  %l2                                       
 2017d10:	a6 10 20 00 	clr  %l3                                       
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
 2017d14:	ac 15 a0 08 	or  %l6, 8, %l6                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
 2017d18:	10 80 00 45 	b  2017e2c <msdos_long_to_short+0x1b4>         
 2017d1c:	ae 15 e0 10 	or  %l7, 0x10, %l7                             
    }                                                                 
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
 2017d20:	80 a0 80 19 	cmp  %g2, %i1                                  
 2017d24:	26 bf ff ed 	bl,a   2017cd8 <msdos_long_to_short+0x60>      <== ALWAYS TAKEN
 2017d28:	c2 4e 00 02 	ldsb  [ %i0 + %g2 ], %g1                       
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
            break;                                                    
                                                                      
    if (i == lfn_len)                                                 
 2017d2c:	80 a0 80 19 	cmp  %g2, %i1                                  <== NOT EXECUTED
 2017d30:	12 bf ff f0 	bne  2017cf0 <msdos_long_to_short+0x78>        <== NOT EXECUTED
 2017d34:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
}                                                                     
 2017d38:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2017d3c:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
 2017d40:	80 a0 00 01 	cmp  %g0, %g1                                  
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
 2017d44:	90 10 00 16 	mov  %l6, %o0                                  
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
 2017d48:	a8 60 3f ff 	subx  %g0, -1, %l4                             
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
 2017d4c:	92 10 00 1b 	mov  %i3, %o1                                  
 2017d50:	40 00 14 d6 	call  201d0a8 <strchr>                         
 2017d54:	aa 10 00 14 	mov  %l4, %l5                                  
 2017d58:	80 a2 20 00 	cmp  %o0, 0                                    
 2017d5c:	12 80 00 12 	bne  2017da4 <msdos_long_to_short+0x12c>       
 2017d60:	ba 10 20 02 	mov  2, %i5                                    
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
 2017d64:	80 8d 20 ff 	btst  0xff, %l4                                
 2017d68:	12 80 00 0e 	bne  2017da0 <msdos_long_to_short+0x128>       
 2017d6c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2017d70:	84 0c 20 ff 	and  %l0, 0xff, %g2                            
 2017d74:	84 00 40 02 	add  %g1, %g2, %g2                             
 2017d78:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
 2017d7c:	80 88 a0 07 	btst  7, %g2                                   
 2017d80:	12 80 00 09 	bne  2017da4 <msdos_long_to_short+0x12c>       
 2017d84:	ba 10 20 01 	mov  1, %i5                                    
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
 2017d88:	90 10 00 17 	mov  %l7, %o0                                  
 2017d8c:	40 00 14 c7 	call  201d0a8 <strchr>                         
 2017d90:	92 10 00 1b 	mov  %i3, %o1                                  
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
 2017d94:	80 a0 00 08 	cmp  %g0, %o0                                  
 2017d98:	10 80 00 03 	b  2017da4 <msdos_long_to_short+0x12c>         
 2017d9c:	ba 40 20 00 	addx  %g0, 0, %i5                              
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
        return MSDOS_NAME_SHORT;                                      
 2017da0:	ba 10 20 01 	mov  1, %i5                                    
                                                                      
#if MSDOS_NAME_TYPE_PRINT                                             
        printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);    
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
 2017da4:	80 8f 60 01 	btst  1, %i5                                   
 2017da8:	02 80 00 2f 	be  2017e64 <msdos_long_to_short+0x1ec>        
 2017dac:	80 a4 7f ff 	cmp  %l1, -1                                   
            return type;                                              
                                                                      
        if (dot_at >= 0)                                              
 2017db0:	02 80 00 0a 	be  2017dd8 <msdos_long_to_short+0x160>        
 2017db4:	80 8d 60 ff 	btst  0xff, %l5                                
        {                                                             
            if (is_dot || ((count - dot_at) > 3))                     
 2017db8:	32 80 00 2e 	bne,a   2017e70 <msdos_long_to_short+0x1f8>    
 2017dbc:	ba 10 20 02 	mov  2, %i5                                    
 2017dc0:	82 27 00 11 	sub  %i4, %l1, %g1                             
 2017dc4:	80 a0 60 03 	cmp  %g1, 3                                    
 2017dc8:	24 80 00 0d 	ble,a   2017dfc <msdos_long_to_short+0x184>    <== ALWAYS TAKEN
 2017dcc:	82 04 3f bf 	add  %l0, -65, %g1                             
            {                                                         
#if MSDOS_NAME_TYPE_PRINT                                             
                printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
                        is_dot, dot_at, count);                       
#endif                                                                
                return MSDOS_NAME_LONG;                               
 2017dd0:	10 80 00 28 	b  2017e70 <msdos_long_to_short+0x1f8>         <== NOT EXECUTED
 2017dd4:	ba 10 20 02 	mov  2, %i5                                    <== NOT EXECUTED
                return MSDOS_NAME_LONG;                               
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            if (count == 8 && !is_dot)                                
 2017dd8:	80 a5 20 00 	cmp  %l4, 0                                    
 2017ddc:	12 80 00 05 	bne  2017df0 <msdos_long_to_short+0x178>       
 2017de0:	80 8d 60 ff 	btst  0xff, %l5                                
 2017de4:	80 a7 20 08 	cmp  %i4, 8                                    
 2017de8:	02 80 00 28 	be  2017e88 <msdos_long_to_short+0x210>        
 2017dec:	80 8d 60 ff 	btst  0xff, %l5                                
#endif                                                                
                return MSDOS_NAME_LONG;                               
            }                                                         
        }                                                             
                                                                      
        if (is_dot)                                                   
 2017df0:	32 80 00 0e 	bne,a   2017e28 <msdos_long_to_short+0x1b0>    
 2017df4:	a2 10 00 1c 	mov  %i4, %l1                                  
            dot_at = count;                                           
        else if ((*name >= 'A') && (*name <= 'Z'))                    
 2017df8:	82 04 3f bf 	add  %l0, -65, %g1                             
 2017dfc:	82 08 60 ff 	and  %g1, 0xff, %g1                            
 2017e00:	80 a0 60 19 	cmp  %g1, 0x19                                 
 2017e04:	28 80 00 09 	bleu,a   2017e28 <msdos_long_to_short+0x1b0>   
 2017e08:	a4 10 20 01 	mov  1, %l2                                    
            uppercase = true;                                         
        else if ((*name >= 'a') && (*name <= 'z'))                    
 2017e0c:	a0 04 3f 9f 	add  %l0, -97, %l0                             
 2017e10:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
 2017e14:	80 a4 20 19 	cmp  %l0, 0x19                                 
 2017e18:	28 80 00 04 	bleu,a   2017e28 <msdos_long_to_short+0x1b0>   
 2017e1c:	a6 10 20 01 	mov  1, %l3                                    
            lowercase = true;                                         
                                                                      
        count++;                                                      
 2017e20:	10 80 00 03 	b  2017e2c <msdos_long_to_short+0x1b4>         
 2017e24:	b8 07 20 01 	inc  %i4                                       
 2017e28:	b8 07 20 01 	inc  %i4                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
 2017e2c:	f6 4e 00 1c 	ldsb  [ %i0 + %i4 ], %i3                       
 2017e30:	80 a6 e0 00 	cmp  %i3, 0                                    
 2017e34:	02 80 00 05 	be  2017e48 <msdos_long_to_short+0x1d0>        
 2017e38:	e0 0e 00 1c 	ldub  [ %i0 + %i4 ], %l0                       
 2017e3c:	80 a7 00 19 	cmp  %i4, %i1                                  
 2017e40:	06 bf ff c0 	bl  2017d40 <msdos_long_to_short+0xc8>         
 2017e44:	82 1e e0 2e 	xor  %i3, 0x2e, %g1                            
                                                                      
        count++;                                                      
        name++;                                                       
    }                                                                 
                                                                      
    if (lowercase && uppercase)                                       
 2017e48:	80 8c e0 ff 	btst  0xff, %l3                                
 2017e4c:	02 80 00 11 	be  2017e90 <msdos_long_to_short+0x218>        
 2017e50:	80 8c a0 ff 	btst  0xff, %l2                                
 2017e54:	22 80 00 07 	be,a   2017e70 <msdos_long_to_short+0x1f8>     <== ALWAYS TAKEN
 2017e58:	ba 10 20 01 	mov  1, %i5                                    
            {                                                         
#if MSDOS_NAME_TYPE_PRINT                                             
                printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
                        is_dot, dot_at, count);                       
#endif                                                                
                return MSDOS_NAME_LONG;                               
 2017e5c:	10 80 00 05 	b  2017e70 <msdos_long_to_short+0x1f8>         <== NOT EXECUTED
 2017e60:	ba 10 20 02 	mov  2, %i5                                    <== NOT EXECUTED
     * Is this a short name ?                                         
     */                                                               
                                                                      
    type = msdos_name_type (lfn, lfn_len);                            
                                                                      
    if (type == MSDOS_NAME_INVALID)                                   
 2017e64:	82 97 60 00 	orcc  %i5, 0, %g1                              
 2017e68:	22 80 00 0d 	be,a   2017e9c <msdos_long_to_short+0x224>     <== NEVER TAKEN
 2017e6c:	b0 10 00 01 	mov  %g1, %i0                                  <== NOT EXECUTED
        printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif                                                                
        return MSDOS_NAME_INVALID;                                    
    }                                                                 
                                                                      
    msdos_filename_unix2dos (lfn, lfn_len, sfn);                      
 2017e70:	90 10 00 18 	mov  %i0, %o0                                  
 2017e74:	92 10 00 19 	mov  %i1, %o1                                  
 2017e78:	40 00 0a a5 	call  201a90c <msdos_filename_unix2dos>        
 2017e7c:	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;                                                      
 2017e80:	10 80 00 06 	b  2017e98 <msdos_long_to_short+0x220>         
 2017e84:	82 10 00 1d 	mov  %i5, %g1                                  
            {                                                         
#if MSDOS_NAME_TYPE_PRINT                                             
                printf ("MSDOS_NAME_TYPE: LONG[2]: is_dot:%d, at:%d cnt\n",
                        is_dot, dot_at, count);                       
#endif                                                                
                return MSDOS_NAME_LONG;                               
 2017e88:	10 bf ff fa 	b  2017e70 <msdos_long_to_short+0x1f8>         
 2017e8c:	ba 10 20 02 	mov  2, %i5                                    
    }                                                                 
                                                                      
#if MSDOS_NAME_TYPE_PRINT                                             
    printf ("MSDOS_NAME_TYPE: SHORT[1]\n");                           
#endif                                                                
    return MSDOS_NAME_SHORT;                                          
 2017e90:	10 bf ff f8 	b  2017e70 <msdos_long_to_short+0x1f8>         
 2017e94:	ba 10 20 01 	mov  1, %i5                                    
                                                                      
#if MSDOS_L2S_PRINT                                                   
    printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif                                                                
    return type;                                                      
}                                                                     
 2017e98:	b0 10 00 01 	mov  %g1, %i0                                  
 2017e9c:	81 c7 e0 08 	ret                                            
 2017ea0:	81 e8 00 00 	restore                                        
                                                                      

0200ea38 <msdos_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
 200ea38:	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))                                                
 200ea3c:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
 200ea40:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 200ea44:	84 0e c0 02 	and  %i3, %g2, %g2                             
    const char *name,                                                 
    size_t namelen,                                                   
    mode_t mode,                                                      
    dev_t dev                                                         
)                                                                     
{                                                                     
 200ea48:	88 10 00 19 	mov  %i1, %g4                                  
 200ea4c:	86 10 00 1a 	mov  %i2, %g3                                  
    msdos_node_type_t    type = 0;                                    
                                                                      
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
 200ea50:	80 a0 80 01 	cmp  %g2, %g1                                  
 200ea54:	02 80 00 07 	be  200ea70 <msdos_mknod+0x38>                 
 200ea58:	b8 10 00 1b 	mov  %i3, %i4                                  
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
    }                                                                 
    else if (S_ISREG(mode))                                           
 200ea5c:	3b 00 00 20 	sethi  %hi(0x8000), %i5                        
 200ea60:	80 a0 80 1d 	cmp  %g2, %i5                                  
 200ea64:	02 80 00 04 	be  200ea74 <msdos_mknod+0x3c>                 <== ALWAYS TAKEN
 200ea68:	b2 10 20 04 	mov  4, %i1                                    
 200ea6c:	30 80 00 06 	b,a   200ea84 <msdos_mknod+0x4c>               <== NOT EXECUTED
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
 200ea70:	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);
 200ea74:	b4 10 00 04 	mov  %g4, %i2                                  
 200ea78:	b6 10 00 03 	mov  %g3, %i3                                  
 200ea7c:	40 00 23 1d 	call  20176f0 <msdos_creat_node>               
 200ea80:	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);                 
 200ea84:	40 00 32 ca 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200ea88:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 200ea8c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
 200ea90:	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;                                                        
}                                                                     
 200ea94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200ea98:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200eaa8 <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 ) {
 200eaa8:	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;            
 200eaac:	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,                             
 200eab0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 200eab4:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
 200eab8:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
 200eabc:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
 200eac0:	19 00 00 20 	sethi  %hi(0x8000), %o4                        <== NOT EXECUTED
 200eac4:	40 00 23 0b 	call  20176f0 <msdos_creat_node>               <== NOT EXECUTED
 200eac8:	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)                                                  
 200eacc:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 200ead0:	12 80 00 05 	bne  200eae4 <msdos_rename+0x3c>               <== NOT EXECUTED
 200ead4:	b4 10 20 e5 	mov  0xe5, %i2                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * mark file removed                                              
     */                                                               
    rc = msdos_set_first_char4file_name(old_loc->mt_entry,            
 200ead8:	f0 06 60 14 	ld  [ %i1 + 0x14 ], %i0                        <== NOT EXECUTED
 200eadc:	40 00 25 78 	call  20180bc <msdos_set_first_char4file_name> <== NOT EXECUTED
 200eae0:	93 ef 60 20 	restore  %i5, 0x20, %o1                        <== NOT EXECUTED
                                        &old_fat_fd->dir_pos,         
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
                                                                      
    return rc;                                                        
}                                                                     
 200eae4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200eae8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200eaec <msdos_rmnod>: #include "msdos.h" int msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc, const rtems_filesystem_location_info_t *pathloc) {
 200eaec:	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;                 
 200eaf0:	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;          
 200eaf4:	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)                     
 200eaf8:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
 200eafc:	80 a0 a0 00 	cmp  %g2, 0                                    
 200eb00:	12 80 00 19 	bne  200eb64 <msdos_rmnod+0x78>                
 200eb04:	f8 02 20 08 	ld  [ %o0 + 8 ], %i4                           
    {                                                                 
        bool is_empty = false;                                        
 200eb08:	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);
 200eb0c:	92 10 00 1d 	mov  %i5, %o1                                  
 200eb10:	40 00 25 b8 	call  20181f0 <msdos_dir_is_empty>             
 200eb14:	94 07 bf ff 	add  %fp, -1, %o2                              
        if (rc != RC_OK)                                              
 200eb18:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200eb1c:	12 80 00 1a 	bne  200eb84 <msdos_rmnod+0x98>                <== NEVER TAKEN
 200eb20:	c2 0f bf ff 	ldub  [ %fp + -1 ], %g1                        
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        if (!is_empty)                                                
 200eb24:	80 a0 60 00 	cmp  %g1, 0                                    
 200eb28:	32 80 00 06 	bne,a   200eb40 <msdos_rmnod+0x54>             
 200eb2c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
        {                                                             
            rtems_set_errno_and_return_minus_one(ENOTEMPTY);          
 200eb30:	40 00 32 9f 	call  201b5ac <__errno>                        
 200eb34:	01 00 00 00 	nop                                            
 200eb38:	10 80 00 08 	b  200eb58 <msdos_rmnod+0x6c>                  
 200eb3c:	82 10 20 5a 	mov  0x5a, %g1	! 5a <PROM_START+0x5a>          
                                                                      
        /*                                                            
         * We deny attempts to delete open directory (if directory is current
         * directory we assume it is open one)                        
         */                                                           
        if (fat_fd->links_num > 1)                                    
 200eb40:	80 a0 60 01 	cmp  %g1, 1                                    
 200eb44:	28 80 00 08 	bleu,a   200eb64 <msdos_rmnod+0x78>            <== ALWAYS TAKEN
 200eb48:	d0 06 60 14 	ld  [ %i1 + 0x14 ], %o0                        
        {                                                             
            rtems_set_errno_and_return_minus_one(EBUSY);              
 200eb4c:	40 00 32 98 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200eb50:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200eb54:	82 10 20 10 	mov  0x10, %g1	! 10 <PROM_START+0x10>          <== NOT EXECUTED
 200eb58:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200eb5c:	81 c7 e0 08 	ret                                            
 200eb60:	91 e8 3f ff 	restore  %g0, -1, %o0                          
         * not used - mount() not implemenetd yet.                    
         */                                                           
    }                                                                 
                                                                      
    /* mark file removed */                                           
    rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
 200eb64:	92 07 60 20 	add  %i5, 0x20, %o1                            
 200eb68:	40 00 25 55 	call  20180bc <msdos_set_first_char4file_name> 
 200eb6c:	94 10 20 e5 	mov  0xe5, %o2                                 
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
    if (rc != RC_OK)                                                  
 200eb70:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200eb74:	12 80 00 04 	bne  200eb84 <msdos_rmnod+0x98>                <== NEVER TAKEN
 200eb78:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
        return rc;                                                    
    }                                                                 
                                                                      
    fat_file_mark_removed(&fs_info->fat, fat_fd);                     
 200eb7c:	40 00 10 1c 	call  2012bec <fat_file_mark_removed>          
 200eb80:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
    return rc;                                                        
}                                                                     
 200eb84:	81 c7 e0 08 	ret                                            
 200eb88:	81 e8 00 00 	restore                                        
                                                                      

02017ea4 <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 ) {
 2017ea4:	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);             
 2017ea8:	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;                     
 2017eac:	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);             
 2017eb0:	94 07 bf fc 	add  %fp, -4, %o2                              
 2017eb4:	40 00 09 fb 	call  201a6a0 <msdos_date_unix2dos>            
 2017eb8:	92 07 bf fe 	add  %fp, -2, %o1                              
                                                                      
    /*                                                                
     * 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);
 2017ebc:	d2 06 60 20 	ld  [ %i1 + 0x20 ], %o1                        
 2017ec0:	7f ff ff 60 	call  2017c40 <fat_cluster_num_to_sector_num>  
 2017ec4:	90 10 00 1d 	mov  %i5, %o0                                  
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
 2017ec8:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
 2017ecc:	f8 17 40 00 	lduh  [ %i5 ], %i4                             
    /*                                                                
     * 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);  
 2017ed0:	f6 0f 60 02 	ldub  [ %i5 + 2 ], %i3                         
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
 2017ed4:	b8 07 3f ff 	add  %i4, -1, %i4                              
    /*                                                                
     * 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);  
 2017ed8:	b7 30 40 1b 	srl  %g1, %i3, %i3                             
    /* byte points to start of 32bytes structure */                   
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
 2017edc:	b8 0f 00 01 	and  %i4, %g1, %i4                             
                                                                      
    time_val = CT_LE_W(time_val);                                     
 2017ee0:	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);  
 2017ee4:	b6 02 00 1b 	add  %o0, %i3, %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);                                     
 2017ee8:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2017eec:	85 30 60 08 	srl  %g1, 8, %g2                               
 2017ef0:	83 30 60 18 	srl  %g1, 0x18, %g1                            
 2017ef4:	82 10 80 01 	or  %g2, %g1, %g1                              
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
 2017ef8:	92 10 00 1b 	mov  %i3, %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 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);                                     
 2017efc:	c2 37 bf fc 	sth  %g1, [ %fp + -4 ]                         
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
 2017f00:	94 07 20 16 	add  %i4, 0x16, %o2                            
 2017f04:	96 10 20 02 	mov  2, %o3                                    
 2017f08:	98 07 bf fc 	add  %fp, -4, %o4                              
 2017f0c:	7f ff ec 5d 	call  2013080 <fat_sector_write>               
 2017f10:	90 10 00 1d 	mov  %i5, %o0                                  
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
 2017f14:	c2 17 bf fe 	lduh  [ %fp + -2 ], %g1                        
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
 2017f18:	92 10 00 1b 	mov  %i3, %o1                                  
    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);                                             
 2017f1c:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 2017f20:	85 30 60 08 	srl  %g1, 8, %g2                               
 2017f24:	83 30 60 18 	srl  %g1, 0x18, %g1                            
 2017f28:	82 10 80 01 	or  %g2, %g1, %g1                              
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
 2017f2c:	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);                                             
 2017f30:	c2 37 bf fe 	sth  %g1, [ %fp + -2 ]                         
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
 2017f34:	96 10 20 02 	mov  2, %o3                                    
 2017f38:	98 07 bf fe 	add  %fp, -2, %o4                              
    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,
 2017f3c:	b4 10 00 08 	mov  %o0, %i2                                  
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
 2017f40:	7f ff ec 50 	call  2013080 <fat_sector_write>               
 2017f44:	90 10 00 1d 	mov  %i5, %o0                                  
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
 2017f48:	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,
 2017f4c:	b2 10 00 08 	mov  %o0, %i1                                  
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
 2017f50:	94 07 20 12 	add  %i4, 0x12, %o2                            
 2017f54:	90 10 00 1d 	mov  %i5, %o0                                  
 2017f58:	96 10 20 02 	mov  2, %o3                                    
 2017f5c:	7f ff ec 49 	call  2013080 <fat_sector_write>               
 2017f60:	98 07 bf fe 	add  %fp, -2, %o4                              
                            2, (char *)(&date));                      
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )                     
 2017f64:	80 a6 60 00 	cmp  %i1, 0                                    
 2017f68:	06 80 00 04 	bl  2017f78 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
 2017f6c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2017f70:	16 80 00 04 	bge  2017f80 <msdos_set_dir_wrt_time_and_date+0xdc><== ALWAYS TAKEN
 2017f74:	80 a2 20 00 	cmp  %o0, 0                                    
        return -1;                                                    
 2017f78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2017f7c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
                            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) )                     
 2017f80:	06 bf ff fe 	bl  2017f78 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
 2017f84:	01 00 00 00 	nop                                            
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
 2017f88:	81 c7 e0 08 	ret                                            
 2017f8c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

020180bc <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 ) {
 20180bc:	9d e3 bf 90 	save  %sp, -112, %sp                           
    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;                          
 20180c0:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    fat_dir_pos_t                        *dir_pos,                    
    unsigned char                         fchar                       
    )                                                                 
{                                                                     
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
 20180c4:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
    uint32_t         dir_block_size;                                  
    fat_pos_t        start = dir_pos->lname;                          
 20180c8:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
 20180cc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    fat_pos_t        end = dir_pos->sname;                            
 20180d0:	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;                          
 20180d4:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
    fat_pos_t        end = dir_pos->sname;                            
 20180d8:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
msdos_set_first_char4file_name(                                       
    rtems_filesystem_mount_table_entry_t *mt_entry,                   
    fat_dir_pos_t                        *dir_pos,                    
    unsigned char                         fchar                       
    )                                                                 
{                                                                     
 20180dc:	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;                          
    fat_pos_t        end = dir_pos->sname;                            
 20180e0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
 20180e4:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
 20180e8:	80 a7 00 01 	cmp  %i4, %g1                                  
 20180ec:	12 80 00 08 	bne  201810c <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
 20180f0:	f8 27 bf f8 	st  %i4, [ %fp + -8 ]                          
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
 20180f4:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
    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) &&                      
 20180f8:	80 88 60 03 	btst  3, %g1                                   
 20180fc:	22 80 00 05 	be,a   2018110 <msdos_set_first_char4file_name+0x54><== NEVER TAKEN
 2018100:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         <== NOT EXECUTED
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
      dir_block_size = fs_info->fat.vol.rdir_size;                    
 2018104:	10 80 00 03 	b  2018110 <msdos_set_first_char4file_name+0x54>
 2018108:	f6 07 60 2c 	ld  [ %i5 + 0x2c ], %i3                        
    else                                                              
      dir_block_size = fs_info->fat.vol.bpc;                          
 201810c:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         <== NOT EXECUTED
                                                                      
    if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)                    
 2018110:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 2018114:	80 a0 7f ff 	cmp  %g1, -1                                   
 2018118:	12 80 00 07 	bne  2018134 <msdos_set_first_char4file_name+0x78>
 201811c:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
      start = dir_pos->sname;                                         
 2018120:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2018124:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
 2018128:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 201812c:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
     * name code was written rather than use the fat_file_write       
     * interface.                                                     
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
 2018130:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
 2018134:	7f ff fe c3 	call  2017c40 <fat_cluster_num_to_sector_num>  
 2018138:	90 10 00 1d 	mov  %i5, %o0                                  
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
 201813c:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
 2018140:	d2 0f 60 02 	ldub  [ %i5 + 2 ], %o1                         
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
 2018144:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
     * 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));      
 2018148:	93 30 40 09 	srl  %g1, %o1, %o1                             
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
 201814c:	94 02 bf ff 	add  %o2, -1, %o2                              
     * name code was written rather than use the fat_file_write       
     * interface.                                                     
     */                                                               
    while (true)                                                      
    {                                                                 
      uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
 2018150:	92 02 00 09 	add  %o0, %o1, %o1                             
                      (start.ofs >> fs_info->fat.vol.sec_log2));      
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
 2018154:	94 0a 80 01 	and  %o2, %g1, %o2                             
 2018158:	90 10 00 1d 	mov  %i5, %o0                                  
 201815c:	96 10 20 01 	mov  1, %o3                                    
 2018160:	7f ff eb c8 	call  2013080 <fat_sector_write>               
 2018164:	98 07 a0 4c 	add  %fp, 0x4c, %o4                            
                             1, &fchar);                              
      if (ret < 0)                                                    
 2018168:	80 a2 20 00 	cmp  %o0, 0                                    
 201816c:	06 80 00 1e 	bl  20181e4 <msdos_set_first_char4file_name+0x128><== NEVER TAKEN
 2018170:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
 2018174:	80 a2 40 1c 	cmp  %o1, %i4                                  
 2018178:	12 80 00 08 	bne  2018198 <msdos_set_first_char4file_name+0xdc><== NEVER TAKEN
 201817c:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
 2018180:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
 2018184:	80 a0 40 02 	cmp  %g1, %g2                                  
 2018188:	12 80 00 05 	bne  201819c <msdos_set_first_char4file_name+0xe0>
 201818c:	82 00 60 20 	add  %g1, 0x20, %g1                            
          return rc;                                                  
        start.ofs = 0;                                                
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
 2018190:	81 c7 e0 08 	ret                                            
 2018194:	91 e8 20 00 	restore  %g0, 0, %o0                           
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
        break;                                                        
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
 2018198:	82 00 60 20 	add  %g1, 0x20, %g1                            <== NOT EXECUTED
      if (start.ofs >= dir_block_size)                                
 201819c:	80 a0 40 1b 	cmp  %g1, %i3                                  
 20181a0:	0a bf ff e4 	bcs  2018130 <msdos_set_first_char4file_name+0x74><== ALWAYS TAKEN
 20181a4:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
      {                                                               
        int rc;                                                       
        if ((end.cln == fs_info->fat.vol.rdir_cl) &&                  
 20181a8:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
 20181ac:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
 20181b0:	12 80 00 06 	bne  20181c8 <msdos_set_first_char4file_name+0x10c><== NOT EXECUTED
 20181b4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
 20181b8:	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) &&                  
 20181bc:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
 20181c0:	12 bf ff f4 	bne  2018190 <msdos_set_first_char4file_name+0xd4><== NOT EXECUTED
 20181c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
          break;                                                      
        rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
 20181c8:	40 00 04 e9 	call  201956c <fat_get_fat_cluster>            <== NOT EXECUTED
 20181cc:	94 07 bf f0 	add  %fp, -16, %o2                             <== NOT EXECUTED
        if ( rc != RC_OK )                                            
 20181d0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 20181d4:	12 80 00 05 	bne  20181e8 <msdos_set_first_char4file_name+0x12c><== NOT EXECUTED
 20181d8:	01 00 00 00 	nop                                            <== NOT EXECUTED
          return rc;                                                  
        start.ofs = 0;                                                
 20181dc:	10 bf ff d5 	b  2018130 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
 20181e0:	c0 27 bf f4 	clr  [ %fp + -12 ]                             <== NOT EXECUTED
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
                             1, &fchar);                              
      if (ret < 0)                                                    
        return -1;                                                    
 20181e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        start.ofs = 0;                                                
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
}                                                                     
 20181e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20181ec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02017f90 <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 ) {
 2017f90:	9d e3 bf 98 	save  %sp, -104, %sp                           
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
 2017f94:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
    /*                                                                
     * 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);
 2017f98:	d2 06 60 20 	ld  [ %i1 + 0x20 ], %o1                        
    )                                                                 
{                                                                     
    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;                                   
 2017f9c:	c0 37 bf fc 	clrh  [ %fp + -4 ]                             
    uint16_t         le_cl_hi = 0;                                    
 2017fa0:	c0 37 bf fe 	clrh  [ %fp + -2 ]                             
                                                                      
    /*                                                                
     * 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);
 2017fa4:	7f ff ff 27 	call  2017c40 <fat_cluster_num_to_sector_num>  
 2017fa8:	90 10 00 1d 	mov  %i5, %o0                                  
    fat_file_fd_t                        *fat_fd                      
    )                                                                 
{                                                                     
    ssize_t          ret1 = 0, ret2 = 0;                              
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
    uint32_t         new_cln = fat_fd->cln;                           
 2017fac:	f8 06 60 1c 	ld  [ %i1 + 0x1c ], %i4                        
    /*                                                                
     * 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);  
 2017fb0:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
 2017fb4:	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);  
 2017fb8:	f4 0f 60 02 	ldub  [ %i5 + 2 ], %i2                         
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
 2017fbc:	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);  
 2017fc0:	b5 30 40 1a 	srl  %g1, %i2, %i2                             
    /* byte from points to start of 32bytes structure */              
    byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);    
 2017fc4:	b6 0e c0 01 	and  %i3, %g1, %i3                             
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
 2017fc8:	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));          
 2017fcc:	83 2f 20 10 	sll  %i4, 0x10, %g1                            
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
 2017fd0:	b2 16 63 ff 	or  %i1, 0x3ff, %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));          
 2017fd4:	83 30 60 18 	srl  %g1, 0x18, %g1                            
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
 2017fd8:	84 0f 00 19 	and  %i4, %i1, %g2                             
    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));          
 2017fdc:	85 28 a0 08 	sll  %g2, 8, %g2                               
 2017fe0:	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);  
 2017fe4:	b4 02 00 1a 	add  %o0, %i2, %i2                             
    /* 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));          
 2017fe8:	c2 37 bf fc 	sth  %g1, [ %fp + -4 ]                         
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
 2017fec:	92 10 00 1a 	mov  %i2, %o1                                  
 2017ff0:	94 06 e0 1a 	add  %i3, 0x1a, %o2                            
 2017ff4:	96 10 20 02 	mov  2, %o3                                    
 2017ff8:	98 07 bf fc 	add  %fp, -4, %o4                              
 2017ffc:	7f ff ec 21 	call  2013080 <fat_sector_write>               
 2018000:	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));   
 2018004:	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,                       
 2018008:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
 201800c:	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,                       
 2018010:	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));   
 2018014:	b3 2e 60 08 	sll  %i1, 8, %i1                               
 2018018:	b9 37 20 08 	srl  %i4, 8, %i4                               
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
 201801c:	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));   
 2018020:	b8 16 40 1c 	or  %i1, %i4, %i4                              
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
 2018024:	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));   
 2018028:	f8 37 bf fe 	sth  %i4, [ %fp + -2 ]                         
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
 201802c:	96 10 20 02 	mov  2, %o3                                    
 2018030:	7f ff ec 14 	call  2013080 <fat_sector_write>               
 2018034:	98 07 bf fe 	add  %fp, -2, %o4                              
                            byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,  
                            (char *)(&le_cl_hi));                     
    if ( (ret1 < 0) || (ret2 < 0) )                                   
 2018038:	80 a2 20 00 	cmp  %o0, 0                                    
 201803c:	06 80 00 04 	bl  201804c <msdos_set_first_cluster_num+0xbc> <== NEVER TAKEN
 2018040:	80 a4 20 00 	cmp  %l0, 0                                    
 2018044:	16 80 00 03 	bge  2018050 <msdos_set_first_cluster_num+0xc0><== ALWAYS TAKEN
 2018048:	b0 10 20 00 	clr  %i0                                       
        return -1;                                                    
 201804c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
    return RC_OK;                                                     
}                                                                     
 2018050:	81 c7 e0 08 	ret                                            
 2018054:	81 e8 00 00 	restore                                        
                                                                      

0200d7d4 <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 ) {
 200d7d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int      ret_val = -1;                                              
  uint32_t onebit;                                                    
                                                                      
  if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {          
 200d7d8:	80 a6 20 00 	cmp  %i0, 0                                    
 200d7dc:	02 80 00 07 	be  200d7f8 <msdos_set_sectors_per_cluster_from_request+0x24>
 200d7e0:	ba 10 20 80 	mov  0x80, %i5                                 
 200d7e4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 200d7e8:	80 a0 60 00 	cmp  %g1, 0                                    
 200d7ec:	32 80 00 03 	bne,a   200d7f8 <msdos_set_sectors_per_cluster_from_request+0x24>
 200d7f0:	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 )                    
{                                                                     
 200d7f4:	ba 10 20 80 	mov  0x80, %i5                                 
 200d7f8:	b0 10 3f ff 	mov  -1, %i0                                   
   * 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 ) {                
 200d7fc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
 200d800:	80 a0 40 1d 	cmp  %g1, %i5                                  
 200d804:	2a 80 00 0c 	bcs,a   200d834 <msdos_set_sectors_per_cluster_from_request+0x60>
 200d808:	bb 37 60 01 	srl  %i5, 1, %i5                               
      fmt_params->sectors_per_cluster = onebit;                       
      if (   fmt_params->sectors_per_cluster                          
          <= 32768L / fmt_params->bytes_per_sector ) {                
 200d80c:	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;                       
 200d810:	fa 26 60 0c 	st  %i5, [ %i1 + 0xc ]                         
      if (   fmt_params->sectors_per_cluster                          
          <= 32768L / fmt_params->bytes_per_sector ) {                
 200d814:	7f ff d3 c9 	call  2002738 <.udiv>                          
 200d818:	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                          
 200d81c:	80 a7 40 08 	cmp  %i5, %o0                                  
 200d820:	18 80 00 05 	bgu  200d834 <msdos_set_sectors_per_cluster_from_request+0x60><== NEVER TAKEN
 200d824:	bb 37 60 01 	srl  %i5, 1, %i5                               
          <= 32768L / fmt_params->bytes_per_sector ) {                
        /* value is small enough so this value is ok */               
        onebit = 1;                                                   
 200d828:	ba 10 20 01 	mov  1, %i5                                    
        ret_val = 0;                                                  
 200d82c:	b0 10 20 00 	clr  %i0                                       
   * 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 ) {           
 200d830:	bb 37 60 01 	srl  %i5, 1, %i5                               
 200d834:	80 a7 60 00 	cmp  %i5, 0                                    
 200d838:	32 bf ff f2 	bne,a   200d800 <msdos_set_sectors_per_cluster_from_request+0x2c>
 200d83c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
        ret_val = 0;                                                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val != 0) {                                                 
 200d840:	80 a6 20 00 	cmp  %i0, 0                                    
 200d844:	02 80 00 06 	be  200d85c <msdos_set_sectors_per_cluster_from_request+0x88><== ALWAYS TAKEN
 200d848:	01 00 00 00 	nop                                            
    errno = EINVAL;                                                   
 200d84c:	40 00 37 58 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200d850:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200d854:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
 200d858:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
 200d85c:	81 c7 e0 08 	ret                                            
 200d860:	81 e8 00 00 	restore                                        
                                                                      

020193e0 <msdos_sync>: return MSDOS_NAME_NOT_FOUND_ERR; } int msdos_sync(rtems_libio_t *iop) {
 20193e0:	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;     
 20193e4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 20193e8:	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;     
 20193ec:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
 20193f0:	94 10 20 00 	clr  %o2                                       
 20193f4:	7f ff c1 24 	call  2009884 <rtems_semaphore_obtain>         
 20193f8:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
 20193fc:	80 a2 20 00 	cmp  %o0, 0                                    
 2019400:	02 80 00 08 	be  2019420 <msdos_sync+0x40>                  <== ALWAYS TAKEN
 2019404:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
 2019408:	40 00 08 69 	call  201b5ac <__errno>                        <== NOT EXECUTED
 201940c:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 2019410:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 2019414:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2019418:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201941c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
 2019420:	7f ff e9 c1 	call  2013b24 <fat_sync>                       
 2019424:	90 10 00 1d 	mov  %i5, %o0                                  
 2019428:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
 201942c:	7f ff c1 5f 	call  20099a8 <rtems_semaphore_release>        
 2019430:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return rc;                                                        
}                                                                     
 2019434:	81 c7 e0 08 	ret                                            
 2019438:	81 e8 00 00 	restore                                        
                                                                      

0200e81c <msdos_unlock>: rtems_fatal_error_occurred(0xdeadbeef); } } void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry) {
 200e81c:	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);  
 200e820:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 200e824:	7f ff ec 61 	call  20099a8 <rtems_semaphore_release>        
 200e828:	d0 00 60 9c 	ld  [ %g1 + 0x9c ], %o0                        
  if (sc != RTEMS_SUCCESSFUL) {                                       
 200e82c:	80 a2 20 00 	cmp  %o0, 0                                    
 200e830:	02 80 00 04 	be  200e840 <msdos_unlock+0x24>                <== ALWAYS TAKEN
 200e834:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
    rtems_fatal_error_occurred(0xdeadbeef);                           
 200e838:	7f ff ed fe 	call  200a030 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 200e83c:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
 200e840:	81 c7 e0 08 	ret                                            
 200e844:	81 e8 00 00 	restore                                        
                                                                      

020040d4 <newlib_delete_hook>: void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) {
 20040d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
    ptr = _REENT;                                                     
 20040d8:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
                                                                      
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
 20040dc:	80 a6 00 19 	cmp  %i0, %i1                                  
 20040e0:	02 80 00 03 	be  20040ec <newlib_delete_hook+0x18>          
 20040e4:	fa 00 60 60 	ld  [ %g1 + 0x60 ], %i5                        
    ptr = _REENT;                                                     
  } else {                                                            
    ptr = deleted_task->libc_reent;                                   
 20040e8:	fa 06 61 54 	ld  [ %i1 + 0x154 ], %i5                       
  }                                                                   
                                                                      
  if (ptr && ptr != _global_impure_ptr) {                             
 20040ec:	80 a7 60 00 	cmp  %i5, 0                                    
 20040f0:	02 80 00 0b 	be  200411c <newlib_delete_hook+0x48>          <== NEVER TAKEN
 20040f4:	03 00 80 6f 	sethi  %hi(0x201bc00), %g1                     
 20040f8:	c2 00 62 a0 	ld  [ %g1 + 0x2a0 ], %g1	! 201bea0 <_global_impure_ptr>
 20040fc:	80 a7 40 01 	cmp  %i5, %g1                                  
 2004100:	02 80 00 07 	be  200411c <newlib_delete_hook+0x48>          
 2004104:	13 00 80 0f 	sethi  %hi(0x2003c00), %o1                     
    _reclaim_reent(ptr);                                              
*/                                                                    
    /*                                                                
     *  Just in case there are some buffers lying around.             
     */                                                               
    _fwalk(ptr, newlib_free_buffers);                                 
 2004108:	90 10 00 1d 	mov  %i5, %o0                                  
 200410c:	40 00 2f 65 	call  200fea0 <_fwalk>                         
 2004110:	92 12 62 c8 	or  %o1, 0x2c8, %o1                            
#if REENT_MALLOCED                                                    
    free(ptr);                                                        
#else                                                                 
    _Workspace_Free(ptr);                                             
 2004114:	40 00 1b ed 	call  200b0c8 <_Workspace_Free>                
 2004118:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  /*                                                                  
   * Require the switch back to another task to install its own       
   */                                                                 
                                                                      
  if ( current_task == deleted_task ) {                               
 200411c:	80 a6 00 19 	cmp  %i0, %i1                                  
 2004120:	12 80 00 04 	bne  2004130 <newlib_delete_hook+0x5c>         
 2004124:	c0 26 61 54 	clr  [ %i1 + 0x154 ]                           
    _REENT = 0;                                                       
 2004128:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
 200412c:	c0 20 60 60 	clr  [ %g1 + 0x60 ]	! 201cc60 <_impure_ptr>    
 2004130:	81 c7 e0 08 	ret                                            
 2004134:	81 e8 00 00 	restore                                        
                                                                      

02003ec8 <newlib_free_buffers>: * task. */ int newlib_free_buffers( FILE *fp ) {
 2003ec8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( fileno(fp) ) {                                             
 2003ecc:	40 00 2e fa 	call  200fab4 <fileno>                         
 2003ed0:	90 10 00 18 	mov  %i0, %o0                                  
 2003ed4:	80 a2 20 02 	cmp  %o0, 2                                    
 2003ed8:	18 80 00 0e 	bgu  2003f10 <newlib_free_buffers+0x48>        <== NEVER TAKEN
 2003edc:	01 00 00 00 	nop                                            
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
 2003ee0:	c2 16 20 0c 	lduh  [ %i0 + 0xc ], %g1                       
 2003ee4:	80 88 60 80 	btst  0x80, %g1                                
 2003ee8:	02 80 00 0c 	be  2003f18 <newlib_free_buffers+0x50>         <== ALWAYS TAKEN
 2003eec:	01 00 00 00 	nop                                            
        free( fp->_bf._base );                                        
 2003ef0:	7f ff fd b0 	call  20035b0 <free>                           <== NOT EXECUTED
 2003ef4:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
        fp->_flags &= ~__SMBF;                                        
 2003ef8:	c2 16 20 0c 	lduh  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
 2003efc:	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;                                        
 2003f00:	82 08 7f 7f 	and  %g1, -129, %g1                            <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
 2003f04:	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;                                        
 2003f08:	10 80 00 04 	b  2003f18 <newlib_free_buffers+0x50>          <== NOT EXECUTED
 2003f0c:	c2 36 20 0c 	sth  %g1, [ %i0 + 0xc ]                        <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
      }                                                               
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
 2003f10:	40 00 2e 29 	call  200f7b4 <fclose>                         <== NOT EXECUTED
 2003f14:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
 2003f18:	81 c7 e0 08 	ret                                            
 2003f1c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02001ca8 <notify>: } void notify (s) char *s; {
 2001ca8:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
    printf ("%s test appears to be inconsistent...\n", s);            
 2001cac:	11 00 80 8a 	sethi  %hi(0x2022800), %o0                     <== NOT EXECUTED
 2001cb0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 2001cb4:	90 12 23 18 	or  %o0, 0x318, %o0                            <== NOT EXECUTED
 2001cb8:	40 00 58 71 	call  2017e7c <printf>                         <== NOT EXECUTED
 2001cbc:	31 00 80 8a 	sethi  %hi(0x2022800), %i0                     <== NOT EXECUTED
    printf ("   PLEASE NOTIFY KARPINKSI!\n");                         
 2001cc0:	40 00 58 b0 	call  2017f80 <puts>                           <== NOT EXECUTED
 2001cc4:	91 ee 23 40 	restore  %i0, 0x340, %o0                       <== NOT EXECUTED
                                                                      

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

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

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

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

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

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

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

02005d94 <oproc>: /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) {
 2005d94:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
 2005d98:	c2 06 60 34 	ld  [ %i1 + 0x34 ], %g1                        
 2005d9c:	80 88 60 01 	btst  1, %g1                                   
 2005da0:	02 80 00 56 	be  2005ef8 <oproc+0x164>                      <== NEVER TAKEN
 2005da4:	f0 2f a0 44 	stb  %i0, [ %fp + 0x44 ]                       
    switch (c) {                                                      
 2005da8:	84 0e 20 ff 	and  %i0, 0xff, %g2                            
 2005dac:	80 a0 a0 09 	cmp  %g2, 9                                    
 2005db0:	22 80 00 2a 	be,a   2005e58 <oproc+0xc4>                    
 2005db4:	c4 06 60 28 	ld  [ %i1 + 0x28 ], %g2                        
 2005db8:	18 80 00 07 	bgu  2005dd4 <oproc+0x40>                      <== ALWAYS TAKEN
 2005dbc:	80 a0 a0 0a 	cmp  %g2, 0xa                                  
 2005dc0:	80 a0 a0 08 	cmp  %g2, 8                                    <== NOT EXECUTED
 2005dc4:	12 80 00 36 	bne  2005e9c <oproc+0x108>                     <== NOT EXECUTED
 2005dc8:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
      }                                                               
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
 2005dcc:	10 80 00 2f 	b  2005e88 <oproc+0xf4>                        <== NOT EXECUTED
 2005dd0:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        <== NOT EXECUTED
oproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
 2005dd4:	02 80 00 06 	be  2005dec <oproc+0x58>                       
 2005dd8:	80 a0 a0 0d 	cmp  %g2, 0xd                                  
 2005ddc:	32 80 00 30 	bne,a   2005e9c <oproc+0x108>                  <== ALWAYS TAKEN
 2005de0:	80 88 60 02 	btst  2, %g1                                   
        tty->column = 0;                                              
      }                                                               
      break;                                                          
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
 2005de4:	10 80 00 0f 	b  2005e20 <oproc+0x8c>                        <== NOT EXECUTED
 2005de8:	80 88 60 10 	btst  0x10, %g1                                <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
    case '\n':                                                        
      if (tty->termios.c_oflag & ONLRET)                              
 2005dec:	80 88 60 20 	btst  0x20, %g1                                
 2005df0:	32 80 00 02 	bne,a   2005df8 <oproc+0x64>                   <== NEVER TAKEN
 2005df4:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
        tty->column = 0;                                              
      if (tty->termios.c_oflag & ONLCR) {                             
 2005df8:	80 88 60 04 	btst  4, %g1                                   
 2005dfc:	02 80 00 40 	be  2005efc <oproc+0x168>                      <== NEVER TAKEN
 2005e00:	90 07 a0 44 	add  %fp, 0x44, %o0                            
        rtems_termios_puts ("\r", 1, tty);                            
 2005e04:	11 00 80 6c 	sethi  %hi(0x201b000), %o0                     
 2005e08:	92 10 20 01 	mov  1, %o1                                    
 2005e0c:	90 12 23 98 	or  %o0, 0x398, %o0                            
 2005e10:	7f ff ff 98 	call  2005c70 <rtems_termios_puts>             
 2005e14:	94 10 00 19 	mov  %i1, %o2                                  
        c = '\n';                                                     
        if (tty->termios.c_oflag & ONLRET)                            
          tty->column = 0;                                            
        break;                                                        
      }                                                               
      tty->column = 0;                                                
 2005e18:	10 80 00 38 	b  2005ef8 <oproc+0x164>                       
 2005e1c:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
        tty->column = 0;                                              
      }                                                               
      break;                                                          
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
 2005e20:	02 80 00 06 	be  2005e38 <oproc+0xa4>                       <== NOT EXECUTED
 2005e24:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
 2005e28:	c4 06 60 28 	ld  [ %i1 + 0x28 ], %g2                        <== NOT EXECUTED
 2005e2c:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
 2005e30:	02 80 00 36 	be  2005f08 <oproc+0x174>                      <== NOT EXECUTED
 2005e34:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
        return;                                                       
      if (tty->termios.c_oflag & OCRNL) {                             
 2005e38:	22 80 00 30 	be,a   2005ef8 <oproc+0x164>                   <== NOT EXECUTED
 2005e3c:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
        c = '\n';                                                     
 2005e40:	84 10 20 0a 	mov  0xa, %g2                                  <== NOT EXECUTED
        if (tty->termios.c_oflag & ONLRET)                            
 2005e44:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
 2005e48:	02 80 00 2c 	be  2005ef8 <oproc+0x164>                      <== NOT EXECUTED
 2005e4c:	c4 2f a0 44 	stb  %g2, [ %fp + 0x44 ]                       <== NOT EXECUTED
          tty->column = 0;                                            
        break;                                                        
      }                                                               
      tty->column = 0;                                                
      break;                                                          
 2005e50:	10 80 00 2a 	b  2005ef8 <oproc+0x164>                       <== NOT EXECUTED
 2005e54:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
 2005e58:	92 10 20 08 	mov  8, %o1                                    
 2005e5c:	86 08 a0 07 	and  %g2, 7, %g3                               
 2005e60:	92 22 40 03 	sub  %o1, %g3, %o1                             
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
 2005e64:	07 00 00 06 	sethi  %hi(0x1800), %g3                        
 2005e68:	82 08 40 03 	and  %g1, %g3, %g1                             
 2005e6c:	80 a0 40 03 	cmp  %g1, %g3                                  
 2005e70:	82 00 80 09 	add  %g2, %o1, %g1                             
 2005e74:	12 80 00 21 	bne  2005ef8 <oproc+0x164>                     <== NEVER TAKEN
 2005e78:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
        tty->column += i;                                             
        rtems_termios_puts ( "        ",  i, tty);                    
 2005e7c:	11 00 80 6c 	sethi  %hi(0x201b000), %o0                     
 2005e80:	10 80 00 20 	b  2005f00 <oproc+0x16c>                       
 2005e84:	90 12 23 a0 	or  %o0, 0x3a0, %o0	! 201b3a0 <rtems_filesystem_default_pathconf+0x5c>
      }                                                               
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
 2005e88:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2005e8c:	04 80 00 1b 	ble  2005ef8 <oproc+0x164>                     <== NOT EXECUTED
 2005e90:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
        c = toupper(c);                                               
      if (!iscntrl(c))                                                
        tty->column++;                                                
 2005e94:	10 80 00 19 	b  2005ef8 <oproc+0x164>                       <== NOT EXECUTED
 2005e98:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
      if (tty->column > 0)                                            
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
 2005e9c:	02 80 00 0d 	be  2005ed0 <oproc+0x13c>                      <== ALWAYS TAKEN
 2005ea0:	c2 0f a0 44 	ldub  [ %fp + 0x44 ], %g1                      
        c = toupper(c);                                               
 2005ea4:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     <== NOT EXECUTED
 2005ea8:	c2 00 60 58 	ld  [ %g1 + 0x58 ], %g1	! 201cc58 <__ctype_ptr__><== NOT EXECUTED
 2005eac:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            <== NOT EXECUTED
 2005eb0:	82 00 40 18 	add  %g1, %i0, %g1                             <== NOT EXECUTED
 2005eb4:	c2 08 60 01 	ldub  [ %g1 + 1 ], %g1                         <== NOT EXECUTED
 2005eb8:	82 08 60 03 	and  %g1, 3, %g1                               <== NOT EXECUTED
 2005ebc:	80 a0 60 02 	cmp  %g1, 2                                    <== NOT EXECUTED
 2005ec0:	22 80 00 02 	be,a   2005ec8 <oproc+0x134>                   <== NOT EXECUTED
 2005ec4:	b0 06 3f e0 	add  %i0, -32, %i0                             <== NOT EXECUTED
 2005ec8:	f0 2f a0 44 	stb  %i0, [ %fp + 0x44 ]                       <== NOT EXECUTED
      if (!iscntrl(c))                                                
 2005ecc:	c2 0f a0 44 	ldub  [ %fp + 0x44 ], %g1                      <== NOT EXECUTED
 2005ed0:	05 00 80 73 	sethi  %hi(0x201cc00), %g2                     
 2005ed4:	c4 00 a0 58 	ld  [ %g2 + 0x58 ], %g2	! 201cc58 <__ctype_ptr__>
 2005ed8:	82 00 80 01 	add  %g2, %g1, %g1                             
 2005edc:	c2 08 60 01 	ldub  [ %g1 + 1 ], %g1                         
 2005ee0:	80 88 60 20 	btst  0x20, %g1                                
 2005ee4:	12 80 00 06 	bne  2005efc <oproc+0x168>                     <== NEVER TAKEN
 2005ee8:	90 07 a0 44 	add  %fp, 0x44, %o0                            
        tty->column++;                                                
 2005eec:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
 2005ef0:	82 00 60 01 	inc  %g1                                       
 2005ef4:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
 2005ef8:	90 07 a0 44 	add  %fp, 0x44, %o0                            
 2005efc:	92 10 20 01 	mov  1, %o1                                    
 2005f00:	7f ff ff 5c 	call  2005c70 <rtems_termios_puts>             
 2005f04:	94 10 00 19 	mov  %i1, %o2                                  
 2005f08:	81 c7 e0 08 	ret                                            
 2005f0c:	81 e8 00 00 	restore                                        
                                                                      

02004834 <partition_free>: * RETURNS: * N/A */ static void partition_free(rtems_part_desc_t *part_desc) {
 2004834:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int part_num;                                                     
                                                                      
    if (part_desc == NULL)                                            
 2004838:	80 a6 20 00 	cmp  %i0, 0                                    
 200483c:	02 80 00 11 	be  2004880 <partition_free+0x4c>              
 2004840:	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));
 2004844:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
    int part_num;                                                     
                                                                      
    if (part_desc == NULL)                                            
        return;                                                       
                                                                      
    if (is_extended(part_desc->sys_type))                             
 2004848:	82 08 60 7f 	and  %g1, 0x7f, %g1                            
 200484c:	80 a0 60 05 	cmp  %g1, 5                                    
 2004850:	22 80 00 04 	be,a   2004860 <partition_free+0x2c>           <== NEVER TAKEN
 2004854:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
        {                                                             
            partition_free(part_desc->sub_part[part_num]);            
        }                                                             
    }                                                                 
                                                                      
    free(part_desc);                                                  
 2004858:	40 00 04 0c 	call  2005888 <free>                           
 200485c:	81 e8 00 00 	restore                                        
 *                                                                    
 * RETURNS:                                                           
 *      N/A                                                           
 */                                                                   
static void                                                           
partition_free(rtems_part_desc_t *part_desc)                          
 2004860:	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]);            
 2004864:	d0 00 60 18 	ld  [ %g1 + 0x18 ], %o0                        <== NOT EXECUTED
 2004868:	7f ff ff f3 	call  2004834 <partition_free>                 <== NOT EXECUTED
 200486c:	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;                                            
 2004870:	80 a7 60 10 	cmp  %i5, 0x10                                 <== NOT EXECUTED
 2004874:	12 bf ff fc 	bne  2004864 <partition_free+0x30>             <== NOT EXECUTED
 2004878:	82 06 00 1d 	add  %i0, %i5, %g1                             <== NOT EXECUTED
 200487c:	30 bf ff f7 	b,a   2004858 <partition_free+0x24>            <== NOT EXECUTED
 2004880:	81 c7 e0 08 	ret                                            
 2004884:	81 e8 00 00 	restore                                        
                                                                      

02004b6c <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) {
 2004b6c:	9d e3 bf 50 	save  %sp, -176, %sp                           
    struct stat         dev_stat;                                     
    rtems_status_code   rc;                                           
    int                 fd;                                           
                                                                      
    fd = open(dev_name, O_RDONLY);                                    
 2004b70:	92 10 20 00 	clr  %o1                                       
 2004b74:	90 10 00 18 	mov  %i0, %o0                                  
 2004b78:	40 00 07 00 	call  2006778 <open>                           
 2004b7c:	ba 10 20 19 	mov  0x19, %i5                                 
    if (fd < 0)                                                       
 2004b80:	80 a2 20 00 	cmp  %o0, 0                                    
 2004b84:	06 80 00 6d 	bl  2004d38 <partition_table_get+0x1cc>        <== NEVER TAKEN
 2004b88:	b8 10 00 08 	mov  %o0, %i4                                  
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    rc = fstat(fd, &dev_stat);                                        
 2004b8c:	40 00 03 69 	call  2005930 <fstat>                          
 2004b90:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rc != RTEMS_SUCCESSFUL)                                       
 2004b94:	80 a2 20 00 	cmp  %o0, 0                                    
 2004b98:	12 80 00 66 	bne  2004d30 <partition_table_get+0x1c4>       <== NEVER TAKEN
 2004b9c:	90 06 60 08 	add  %i1, 8, %o0                               
    {                                                                 
        close(fd);                                                    
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    strncpy (disk_desc->dev_name, dev_name, 15);                      
 2004ba0:	92 10 00 18 	mov  %i0, %o1                                  
 2004ba4:	40 00 47 57 	call  2016900 <strncpy>                        
 2004ba8:	94 10 20 0f 	mov  0xf, %o2                                  
    disk_desc->dev = dev_stat.st_rdev;                                
 2004bac:	c4 1f bf d0 	ldd  [ %fp + -48 ], %g2                        
 2004bb0:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
 2004bb4:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
 2004bb8:	80 a0 a0 00 	cmp  %g2, 0                                    
 2004bbc:	02 80 00 03 	be  2004bc8 <partition_table_get+0x5c>         <== ALWAYS TAKEN
 2004bc0:	82 10 22 00 	mov  0x200, %g1                                
 2004bc4:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
 2004bc8:	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;                               
 2004bcc:	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);                               
 2004bd0:	90 10 00 1c 	mov  %i4, %o0                                  
 2004bd4:	92 10 20 00 	clr  %o1                                       
 2004bd8:	94 10 20 00 	clr  %o2                                       
 2004bdc:	96 10 20 00 	clr  %o3                                       
 2004be0:	40 00 04 47 	call  2005cfc <lseek>                          
 2004be4:	ba 10 20 1b 	mov  0x1b, %i5                                 
    if (new_off != off) {                                             
 2004be8:	80 92 00 09 	orcc  %o0, %o1, %g0                            
 2004bec:	12 80 00 09 	bne  2004c10 <partition_table_get+0xa4>        <== NEVER TAKEN
 2004bf0:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
 2004bf4:	90 10 00 1c 	mov  %i4, %o0                                  
 2004bf8:	92 10 20 00 	clr  %o1                                       
 2004bfc:	7f ff ff 2e 	call  20048b4 <get_sector.part.0>              
 2004c00:	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)                                       
 2004c04:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2004c08:	02 80 00 06 	be  2004c20 <partition_table_get+0xb4>         <== ALWAYS TAKEN
 2004c0c:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
    {                                                                 
        if (sector)                                                   
 2004c10:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2004c14:	02 80 00 47 	be  2004d30 <partition_table_get+0x1c4>        <== NOT EXECUTED
 2004c18:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2004c1c:	30 80 00 19 	b,a   2004c80 <partition_table_get+0x114>      <== 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) &&    
 2004c20:	c4 0a 22 02 	ldub  [ %o0 + 0x202 ], %g2                     
 2004c24:	80 a0 a0 55 	cmp  %g2, 0x55                                 
 2004c28:	12 80 00 06 	bne  2004c40 <partition_table_get+0xd4>        <== NEVER TAKEN
 2004c2c:	82 10 20 00 	clr  %g1                                       
 2004c30:	c2 0a 22 03 	ldub  [ %o0 + 0x203 ], %g1                     
 2004c34:	82 18 60 aa 	xor  %g1, 0xaa, %g1                            
 2004c38:	80 a0 00 01 	cmp  %g0, %g1                                  
 2004c3c:	82 60 3f ff 	subx  %g0, -1, %g1                             
            free(sector);                                             
        return rc;                                                    
    }                                                                 
                                                                      
    /* check if the partition table structure is MS-DOS style */      
    if (!msdos_signature_check(sector))                               
 2004c40:	80 a0 60 00 	cmp  %g1, 0                                    
 2004c44:	32 80 00 05 	bne,a   2004c58 <partition_table_get+0xec>     <== ALWAYS TAKEN
 2004c48:	b0 02 21 c2 	add  %o0, 0x1c2, %i0                           
    {                                                                 
        free(sector);                                                 
 2004c4c:	40 00 03 0f 	call  2005888 <free>                           <== NOT EXECUTED
 2004c50:	ba 10 20 19 	mov  0x19, %i5                                 <== NOT EXECUTED
 2004c54:	30 80 00 37 	b,a   2004d30 <partition_table_get+0x1c4>      <== NOT EXECUTED
 2004c58:	b4 10 00 19 	mov  %i1, %i2                                  
                                                                      
    /* read and process 4 primary partition descriptors */            
                                                                      
    data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;           
                                                                      
    for (part_num = 0;                                                
 2004c5c:	b6 10 20 00 	clr  %i3                                       
 * RETURNS:                                                           
 *      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)
 2004c60:	91 2e e0 04 	sll  %i3, 4, %o0                               
 2004c64:	92 07 bf b4 	add  %fp, -76, %o1                             
 2004c68:	7f ff ff 29 	call  200490c <data_to_part_desc.part.1>       
 2004c6c:	90 06 00 08 	add  %i0, %o0, %o0                             
    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)                                   
 2004c70:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2004c74:	02 80 00 06 	be  2004c8c <partition_table_get+0x120>        <== ALWAYS TAKEN
 2004c78:	c2 07 bf b4 	ld  [ %fp + -76 ], %g1                         
        {                                                             
            free(sector);                                             
 2004c7c:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         <== NOT EXECUTED
 2004c80:	40 00 03 02 	call  2005888 <free>                           <== NOT EXECUTED
 2004c84:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2004c88:	30 80 00 2a 	b,a   2004d30 <partition_table_get+0x1c4>      <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
 2004c8c:	80 a0 60 00 	cmp  %g1, 0                                    
 2004c90:	02 80 00 0b 	be  2004cbc <partition_table_get+0x150>        <== NEVER TAKEN
 2004c94:	84 06 e0 01 	add  %i3, 1, %g2                               
        {                                                             
            part_desc->log_id = part_num + 1;                         
            part_desc->disk_desc = disk_desc;                         
            part_desc->end = part_desc->start + part_desc->size - 1;  
 2004c98:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
            return rc;                                                
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
        {                                                             
            part_desc->log_id = part_num + 1;                         
 2004c9c:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
            part_desc->disk_desc = disk_desc;                         
            part_desc->end = part_desc->start + part_desc->size - 1;  
 2004ca0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
        {                                                             
            part_desc->log_id = part_num + 1;                         
            part_desc->disk_desc = disk_desc;                         
 2004ca4:	f2 20 60 10 	st  %i1, [ %g1 + 0x10 ]                        
            part_desc->end = part_desc->start + part_desc->size - 1;  
 2004ca8:	84 00 c0 02 	add  %g3, %g2, %g2                             
 2004cac:	84 00 bf ff 	add  %g2, -1, %g2                              
 2004cb0:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
            disk_desc->partitions[part_num] = part_desc;              
 2004cb4:	10 80 00 03 	b  2004cc0 <partition_table_get+0x154>         
 2004cb8:	c2 26 a0 28 	st  %g1, [ %i2 + 0x28 ]                        
        }                                                             
        else                                                          
        {                                                             
            disk_desc->partitions[part_num] = NULL;                   
 2004cbc:	c0 26 a0 28 	clr  [ %i2 + 0x28 ]                            <== NOT EXECUTED
                                                                      
    data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;           
                                                                      
    for (part_num = 0;                                                
         part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;     
         part_num++)                                                  
 2004cc0:	b6 06 e0 01 	inc  %i3                                       
                                                                      
    /* read and process 4 primary partition descriptors */            
                                                                      
    data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;           
                                                                      
    for (part_num = 0;                                                
 2004cc4:	80 a6 e0 04 	cmp  %i3, 4                                    
 2004cc8:	12 bf ff e6 	bne  2004c60 <partition_table_get+0xf4>        
 2004ccc:	b4 06 a0 04 	add  %i2, 4, %i2                               
        }                                                             
                                                                      
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
 2004cd0:	40 00 02 ee 	call  2005888 <free>                           
 2004cd4:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
                                                                      
    disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
 2004cd8:	f6 26 60 24 	st  %i3, [ %i1 + 0x24 ]                        
 2004cdc:	b6 10 20 00 	clr  %i3                                       
 * RETURNS:                                                           
 *      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)
 2004ce0:	b4 06 40 1b 	add  %i1, %i3, %i2                             
       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];                  
 2004ce4:	d4 06 a0 28 	ld  [ %i2 + 0x28 ], %o2                        
        if (part_desc != NULL && is_extended(part_desc->sys_type))    
 2004ce8:	80 a2 a0 00 	cmp  %o2, 0                                    
 2004cec:	02 80 00 0d 	be  2004d20 <partition_table_get+0x1b4>        <== NEVER TAKEN
 2004cf0:	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));
 2004cf4:	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))    
 2004cf8:	82 08 60 7f 	and  %g1, 0x7f, %g1                            
 2004cfc:	80 a0 60 05 	cmp  %g1, 5                                    
 2004d00:	32 80 00 09 	bne,a   2004d24 <partition_table_get+0x1b8>    
 2004d04:	b6 06 e0 04 	add  %i3, 4, %i3                               
        {                                                             
            read_extended_partition(fd, part_desc->start, part_desc); 
 2004d08:	d2 02 a0 04 	ld  [ %o2 + 4 ], %o1                           
 2004d0c:	7f ff ff 31 	call  20049d0 <read_extended_partition>        
 2004d10:	90 10 00 1c 	mov  %i4, %o0                                  
            free(part_desc);                                          
 2004d14:	40 00 02 dd 	call  2005888 <free>                           
 2004d18:	d0 07 bf b4 	ld  [ %fp + -76 ], %o0                         
            disk_desc->partitions[part_num] = NULL;                   
 2004d1c:	c0 26 a0 28 	clr  [ %i2 + 0x28 ]                            
 2004d20:	b6 06 e0 04 	add  %i3, 4, %i3                               
                                                                      
    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;                                                
 2004d24:	80 a6 e0 10 	cmp  %i3, 0x10                                 
 2004d28:	12 bf ff ef 	bne  2004ce4 <partition_table_get+0x178>       
 2004d2c:	b4 06 40 1b 	add  %i1, %i3, %i2                             
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
                                              RTEMS_IDE_SECTOR_SIZE;  
                                                                      
    rc = read_mbr(fd, disk_desc);                                     
                                                                      
    close(fd);                                                        
 2004d30:	40 00 02 19 	call  2005594 <close>                          
 2004d34:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    return rc;                                                        
}                                                                     
 2004d38:	81 c7 e0 08 	ret                                            
 2004d3c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

02004598 <pathconf>: */ long pathconf( const char *path, int name ) {
 2004598:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_RDONLY );                                        
 200459c:	92 10 20 00 	clr  %o1                                       
 20045a0:	7f ff ff 6f 	call  200435c <open>                           
 20045a4:	90 10 00 18 	mov  %i0, %o0                                  
  if ( fd == -1 )                                                     
 20045a8:	80 a2 3f ff 	cmp  %o0, -1                                   
 20045ac:	02 80 00 09 	be  20045d0 <pathconf+0x38>                    <== ALWAYS TAKEN
 20045b0:	ba 10 00 08 	mov  %o0, %i5                                  
    return -1;                                                        
                                                                      
  status = fpathconf( fd, name );                                     
 20045b4:	40 00 14 15 	call  2009608 <fpathconf>                      <== NOT EXECUTED
 20045b8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 20045bc:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  (void) close( fd );                                                 
 20045c0:	40 00 13 e5 	call  2009554 <close>                          <== NOT EXECUTED
 20045c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return status;                                                      
 20045c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20045cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
}                                                                     
 20045d0:	81 c7 e0 08 	ret                                            
 20045d4:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

0200cfac <pipe_create>: static uint16_t rtems_pipe_no = 0; int pipe_create( int filsdes[2] ) {
 200cfac:	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)          
 200cfb0:	11 00 80 81 	sethi  %hi(0x2020400), %o0                     
 200cfb4:	92 10 21 ff 	mov  0x1ff, %o1                                
 200cfb8:	40 00 05 4e 	call  200e4f0 <rtems_mkdir>                    
 200cfbc:	90 12 23 30 	or  %o0, 0x330, %o0                            
 200cfc0:	80 a2 20 00 	cmp  %o0, 0                                    
 200cfc4:	12 80 00 47 	bne  200d0e0 <pipe_create+0x134>               
 200cfc8:	03 00 00 19 	sethi  %hi(0x6400), %g1                        
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
 200cfcc:	82 10 62 6f 	or  %g1, 0x26f, %g1	! 666f <PROM_START+0x666f> 
 200cfd0:	c2 37 bf f8 	sth  %g1, [ %fp + -8 ]                         
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
 200cfd4:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
 200cfd8:	d4 10 62 90 	lduh  [ %g1 + 0x290 ], %o2	! 2022290 <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);                                 
 200cfdc:	05 0b dd 1b 	sethi  %hi(0x2f746c00), %g2                    
 200cfe0:	84 10 a1 70 	or  %g2, 0x170, %g2	! 2f746d70 <RAM_END+0x2d346d70>
 200cfe4:	07 0b cb 99 	sethi  %hi(0x2f2e6400), %g3                    
 200cfe8:	86 10 e2 69 	or  %g3, 0x269, %g3	! 2f2e6669 <RAM_END+0x2cee6669>
 200cfec:	c4 3f bf f0 	std  %g2, [ %fp + -16 ]                        
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
 200cff0:	84 02 a0 01 	add  %o2, 1, %g2                               
 200cff4:	90 07 bf fa 	add  %fp, -6, %o0                              
 200cff8:	c4 30 62 90 	sth  %g2, [ %g1 + 0x290 ]                      
 200cffc:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
 200d000:	13 00 80 81 	sethi  %hi(0x2020400), %o1                     
 200d004:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
 200d008:	40 00 13 56 	call  2011d60 <sprintf>                        
 200d00c:	92 12 63 38 	or  %o1, 0x338, %o1                            
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
 200d010:	90 07 bf f0 	add  %fp, -16, %o0                             
 200d014:	40 00 04 8d 	call  200e248 <mkfifo>                         
 200d018:	92 10 21 80 	mov  0x180, %o1                                
 200d01c:	80 a2 20 00 	cmp  %o0, 0                                    
 200d020:	02 80 00 05 	be  200d034 <pipe_create+0x88>                 <== ALWAYS TAKEN
 200d024:	90 07 bf f0 	add  %fp, -16, %o0                             
    if (errno != EEXIST){                                             
 200d028:	40 00 0f e3 	call  2010fb4 <__errno>                        <== NOT EXECUTED
 200d02c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 200d030:	30 80 00 2d 	b,a   200d0e4 <pipe_create+0x138>              <== NOT EXECUTED
    return -1;                                                        
    /* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */           
  }                                                                   
                                                                      
  /* Non-blocking open to avoid waiting for writers */                
  filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);                 
 200d034:	7f ff df 15 	call  2004c88 <open>                           
 200d038:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
  if (filsdes[0] < 0) {                                               
 200d03c:	80 a2 20 00 	cmp  %o0, 0                                    
 200d040:	16 80 00 06 	bge  200d058 <pipe_create+0xac>                
 200d044:	d0 26 00 00 	st  %o0, [ %i0 ]                               
    err = errno;                                                      
 200d048:	40 00 0f db 	call  2010fb4 <__errno>                        
 200d04c:	01 00 00 00 	nop                                            
 200d050:	10 80 00 1c 	b  200d0c0 <pipe_create+0x114>                 
 200d054:	fa 02 00 00 	ld  [ %o0 ], %i5                               
     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]);                                
 200d058:	03 00 80 86 	sethi  %hi(0x2021800), %g1                     
 200d05c:	c4 00 61 a4 	ld  [ %g1 + 0x1a4 ], %g2	! 20219a4 <rtems_libio_number_iops>
 200d060:	80 a2 00 02 	cmp  %o0, %g2                                  
 200d064:	1a 80 00 08 	bcc  200d084 <pipe_create+0xd8>                <== NEVER TAKEN
 200d068:	82 10 20 00 	clr  %g1                                       
 200d06c:	83 2a 20 03 	sll  %o0, 3, %g1                               
 200d070:	91 2a 20 06 	sll  %o0, 6, %o0                               
 200d074:	90 22 00 01 	sub  %o0, %g1, %o0                             
 200d078:	03 00 80 89 	sethi  %hi(0x2022400), %g1                     
 200d07c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1	! 202240c <rtems_libio_iops>
 200d080:	82 00 40 08 	add  %g1, %o0, %g1                             
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
 200d084:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
 200d088:	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;                              
 200d08c:	84 08 bf fe 	and  %g2, -2, %g2                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
 200d090:	92 10 20 01 	mov  1, %o1                                    
 200d094:	7f ff de fd 	call  2004c88 <open>                           
 200d098:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
 200d09c:	d0 26 20 04 	st  %o0, [ %i0 + 4 ]                           
                                                                      
    if (filsdes[1] < 0) {                                             
 200d0a0:	80 a2 20 00 	cmp  %o0, 0                                    
 200d0a4:	16 80 00 07 	bge  200d0c0 <pipe_create+0x114>               
 200d0a8:	ba 10 20 00 	clr  %i5                                       
    err = errno;                                                      
 200d0ac:	40 00 0f c2 	call  2010fb4 <__errno>                        
 200d0b0:	01 00 00 00 	nop                                            
 200d0b4:	fa 02 00 00 	ld  [ %o0 ], %i5                               
    close(filsdes[0]);                                                
 200d0b8:	7f ff da e8 	call  2003c58 <close>                          
 200d0bc:	d0 06 00 00 	ld  [ %i0 ], %o0                               
    }                                                                 
  unlink(fifopath);                                                   
 200d0c0:	7f ff ea a6 	call  2007b58 <unlink>                         
 200d0c4:	90 07 bf f0 	add  %fp, -16, %o0                             
  }                                                                   
  if(err != 0)                                                        
 200d0c8:	80 a7 60 00 	cmp  %i5, 0                                    
 200d0cc:	02 80 00 06 	be  200d0e4 <pipe_create+0x138>                
 200d0d0:	b0 10 20 00 	clr  %i0                                       
    rtems_set_errno_and_return_minus_one(err);                        
 200d0d4:	40 00 0f b8 	call  2010fb4 <__errno>                        
 200d0d8:	01 00 00 00 	nop                                            
 200d0dc:	fa 22 00 00 	st  %i5, [ %o0 ]                               
{                                                                     
  rtems_libio_t *iop;                                                 
  int err = 0;                                                        
                                                                      
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
 200d0e0:	b0 10 3f ff 	mov  -1, %i0                                   
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
}                                                                     
 200d0e4:	81 c7 e0 08 	ret                                            
 200d0e8:	81 e8 00 00 	restore                                        
                                                                      

0200e4d4 <pipe_ioctl>: pipe_control_t *pipe, ioctl_command_t cmd, void *buffer, rtems_libio_t *iop ) {
 200e4d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (cmd == FIONREAD) {                                              
 200e4d8:	03 10 01 19 	sethi  %hi(0x40046400), %g1                    
 200e4dc:	82 10 62 7f 	or  %g1, 0x27f, %g1	! 4004667f <RAM_END+0x3dc4667f>
 200e4e0:	80 a6 40 01 	cmp  %i1, %g1                                  
 200e4e4:	12 80 00 11 	bne  200e528 <pipe_ioctl+0x54>                 
 200e4e8:	80 a6 a0 00 	cmp  %i2, 0                                    
    if (buffer == NULL)                                               
 200e4ec:	02 80 00 11 	be  200e530 <pipe_ioctl+0x5c>                  
 200e4f0:	92 10 20 00 	clr  %o1                                       
      return -EFAULT;                                                 
                                                                      
    if (! PIPE_LOCK(pipe))                                            
 200e4f4:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
 200e4f8:	7f ff ea 97 	call  2008f54 <rtems_semaphore_obtain>         
 200e4fc:	94 10 20 00 	clr  %o2                                       
 200e500:	80 a2 20 00 	cmp  %o0, 0                                    
 200e504:	12 80 00 0d 	bne  200e538 <pipe_ioctl+0x64>                 <== NEVER TAKEN
 200e508:	01 00 00 00 	nop                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
 200e50c:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
    PIPE_UNLOCK(pipe);                                                
 200e510:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
    if (! PIPE_LOCK(pipe))                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
 200e514:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    PIPE_UNLOCK(pipe);                                                
 200e518:	7f ff ea d8 	call  2009078 <rtems_semaphore_release>        
 200e51c:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
 200e520:	81 c7 e0 08 	ret                                            
 200e524:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return -EINVAL;                                                     
 200e528:	81 c7 e0 08 	ret                                            
 200e52c:	91 e8 3f ea 	restore  %g0, -22, %o0                         
  rtems_libio_t   *iop                                                
)                                                                     
{                                                                     
  if (cmd == FIONREAD) {                                              
    if (buffer == NULL)                                               
      return -EFAULT;                                                 
 200e530:	81 c7 e0 08 	ret                                            
 200e534:	91 e8 3f f2 	restore  %g0, -14, %o0                         
    PIPE_UNLOCK(pipe);                                                
    return 0;                                                         
  }                                                                   
                                                                      
  return -EINVAL;                                                     
}                                                                     
 200e538:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e53c:	91 e8 3f fc 	restore  %g0, -4, %o0                          <== NOT EXECUTED
                                                                      

0200e168 <pipe_read>: pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) {
 200e168:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
 200e16c:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
 200e170:	92 10 20 00 	clr  %o1                                       
 200e174:	94 10 20 00 	clr  %o2                                       
 200e178:	7f ff eb 77 	call  2008f54 <rtems_semaphore_obtain>         
 200e17c:	ba 10 00 18 	mov  %i0, %i5                                  
 200e180:	80 a2 20 00 	cmp  %o0, 0                                    
 200e184:	32 80 00 5d 	bne,a   200e2f8 <pipe_read+0x190>              <== NEVER TAKEN
 200e188:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
 200e18c:	10 80 00 4d 	b  200e2c0 <pipe_read+0x158>                   
 200e190:	b0 10 20 00 	clr  %i0                                       
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
    while (PIPE_EMPTY(pipe)) {                                        
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
 200e194:	80 a0 60 00 	cmp  %g1, 0                                    
 200e198:	32 80 00 04 	bne,a   200e1a8 <pipe_read+0x40>               
 200e19c:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
  rtems_libio_t  *iop                                                 
)                                                                     
{                                                                     
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
 200e1a0:	10 80 00 4c 	b  200e2d0 <pipe_read+0x168>                   
 200e1a4:	b8 10 20 00 	clr  %i4                                       
    while (PIPE_EMPTY(pipe)) {                                        
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
        goto out_locked;                                              
                                                                      
      if (LIBIO_NODELAY(iop)) {                                       
 200e1a8:	80 88 60 01 	btst  1, %g1                                   
 200e1ac:	32 80 00 49 	bne,a   200e2d0 <pipe_read+0x168>              
 200e1b0:	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 ++;                                        
 200e1b4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
      PIPE_UNLOCK(pipe);                                              
 200e1b8:	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 ++;                                        
 200e1bc:	82 00 60 01 	inc  %g1                                       
      PIPE_UNLOCK(pipe);                                              
 200e1c0:	7f ff eb ae 	call  2009078 <rtems_semaphore_release>        
 200e1c4:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
      if (! PIPE_READWAIT(pipe))                                      
 200e1c8:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
 200e1cc:	40 00 05 6e 	call  200f784 <rtems_barrier_wait>             
 200e1d0:	92 10 20 00 	clr  %o1                                       
 200e1d4:	80 a0 00 08 	cmp  %g0, %o0                                  
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
 200e1d8:	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))                                      
 200e1dc:	b8 60 20 00 	subx  %g0, 0, %i4                              
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
 200e1e0:	92 10 20 00 	clr  %o1                                       
 200e1e4:	94 10 20 00 	clr  %o2                                       
 200e1e8:	7f ff eb 5b 	call  2008f54 <rtems_semaphore_obtain>         
 200e1ec:	b8 0f 3f fc 	and  %i4, -4, %i4                              
 200e1f0:	80 a2 20 00 	cmp  %o0, 0                                    
 200e1f4:	12 80 00 3b 	bne  200e2e0 <pipe_read+0x178>                 <== NEVER TAKEN
 200e1f8:	80 a7 20 00 	cmp  %i4, 0                                    
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
 200e1fc:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
 200e200:	82 00 7f ff 	add  %g1, -1, %g1                              
      if (ret != 0)                                                   
 200e204:	12 80 00 33 	bne  200e2d0 <pipe_read+0x168>                 <== NEVER TAKEN
 200e208:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
    while (PIPE_EMPTY(pipe)) {                                        
 200e20c:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
 200e210:	80 a7 20 00 	cmp  %i4, 0                                    
 200e214:	22 bf ff e0 	be,a   200e194 <pipe_read+0x2c>                
 200e218:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
      if (ret != 0)                                                   
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
 200e21c:	82 26 80 18 	sub  %i2, %i0, %g1                             
 200e220:	80 a7 00 01 	cmp  %i4, %g1                                  
 200e224:	38 80 00 02 	bgu,a   200e22c <pipe_read+0xc4>               
 200e228:	b8 10 00 01 	mov  %g1, %i4                                  
    chunk1 = pipe->Size - pipe->Start;                                
 200e22c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 200e230:	e0 07 60 04 	ld  [ %i5 + 4 ], %l0                           
 200e234:	d2 07 40 00 	ld  [ %i5 ], %o1                               
 200e238:	a0 24 00 01 	sub  %l0, %g1, %l0                             
    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);       
 200e23c:	94 10 00 1c 	mov  %i4, %o2                                  
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
    chunk1 = pipe->Size - pipe->Start;                                
    if (chunk > chunk1) {                                             
 200e240:	80 a7 00 10 	cmp  %i4, %l0                                  
 200e244:	90 06 40 18 	add  %i1, %i0, %o0                             
 200e248:	04 80 00 09 	ble  200e26c <pipe_read+0x104>                 
 200e24c:	92 02 40 01 	add  %o1, %g1, %o1                             
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);      
 200e250:	40 00 11 1d 	call  20126c4 <memcpy>                         
 200e254:	94 10 00 10 	mov  %l0, %o2                                  
      memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);   
 200e258:	90 06 00 10 	add  %i0, %l0, %o0                             
 200e25c:	d2 07 40 00 	ld  [ %i5 ], %o1                               
 200e260:	90 06 40 08 	add  %i1, %o0, %o0                             
 200e264:	10 80 00 02 	b  200e26c <pipe_read+0x104>                   
 200e268:	94 27 00 10 	sub  %i4, %l0, %o2                             
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
 200e26c:	40 00 11 16 	call  20126c4 <memcpy>                         
 200e270:	01 00 00 00 	nop                                            
                                                                      
    pipe->Start += chunk;                                             
 200e274:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
    pipe->Start %= pipe->Size;                                        
 200e278:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
 200e27c:	40 00 41 11 	call  201e6c0 <.urem>                          
 200e280:	90 07 00 08 	add  %i4, %o0, %o0                             
    pipe->Length -= chunk;                                            
 200e284:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
    pipe->Start %= pipe->Size;                                        
 200e288:	d0 27 60 08 	st  %o0, [ %i5 + 8 ]                           
    pipe->Length -= chunk;                                            
 200e28c:	82 20 40 1c 	sub  %g1, %i4, %g1                             
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
 200e290:	80 a0 60 00 	cmp  %g1, 0                                    
 200e294:	12 80 00 03 	bne  200e2a0 <pipe_read+0x138>                 
 200e298:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
      pipe->Start = 0;                                                
 200e29c:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
                                                                      
    if (pipe->waitingWriters > 0)                                     
 200e2a0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 200e2a4:	80 a0 60 00 	cmp  %g1, 0                                    
 200e2a8:	22 80 00 06 	be,a   200e2c0 <pipe_read+0x158>               
 200e2ac:	b0 06 00 1c 	add  %i0, %i4, %i0                             
      PIPE_WAKEUPWRITERS(pipe);                                       
 200e2b0:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
 200e2b4:	40 00 05 1e 	call  200f72c <rtems_barrier_release>          
 200e2b8:	92 07 bf fc 	add  %fp, -4, %o1                              
    read += chunk;                                                    
 200e2bc:	b0 06 00 1c 	add  %i0, %i4, %i0                             
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
 200e2c0:	80 a6 00 1a 	cmp  %i0, %i2                                  
 200e2c4:	2a bf ff d3 	bcs,a   200e210 <pipe_read+0xa8>               
 200e2c8:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
 200e2cc:	b8 10 20 00 	clr  %i4                                       
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
 200e2d0:	7f ff eb 6a 	call  2009078 <rtems_semaphore_release>        
 200e2d4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
out_nolock:                                                           
  if (read > 0)                                                       
 200e2d8:	10 80 00 04 	b  200e2e8 <pipe_read+0x180>                   
 200e2dc:	80 a6 20 00 	cmp  %i0, 0                                    
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_READWAIT(pipe))                                      
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
 200e2e0:	b8 10 3f fc 	mov  -4, %i4                                   <== NOT EXECUTED
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
                                                                      
out_nolock:                                                           
  if (read > 0)                                                       
 200e2e4:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
 200e2e8:	14 80 00 04 	bg  200e2f8 <pipe_read+0x190>                  
 200e2ec:	01 00 00 00 	nop                                            
    return read;                                                      
  return ret;                                                         
 200e2f0:	81 c7 e0 08 	ret                                            
 200e2f4:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
}                                                                     
 200e2f8:	81 c7 e0 08 	ret                                            
 200e2fc:	81 e8 00 00 	restore                                        
                                                                      

0200dc58 <pipe_release>: void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) {
 200dc58:	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);                                          
 200dc5c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
void pipe_release(                                                    
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
  pipe_control_t *pipe = *pipep;                                      
 200dc60:	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)                                        
 200dc64:	80 88 60 02 	btst  2, %g1                                   
 200dc68:	02 80 00 05 	be  200dc7c <pipe_release+0x24>                
 200dc6c:	b8 08 60 06 	and  %g1, 6, %i4                               
     pipe->Readers --;                                                
 200dc70:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
 200dc74:	84 00 bf ff 	add  %g2, -1, %g2                              
 200dc78:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
  if (mode & LIBIO_FLAGS_WRITE)                                       
 200dc7c:	80 88 60 04 	btst  4, %g1                                   
 200dc80:	02 80 00 05 	be  200dc94 <pipe_release+0x3c>                
 200dc84:	01 00 00 00 	nop                                            
     pipe->Writers --;                                                
 200dc88:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200dc8c:	82 00 7f ff 	add  %g1, -1, %g1                              
 200dc90:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
                                                                      
  PIPE_UNLOCK(pipe);                                                  
 200dc94:	7f ff ec f9 	call  2009078 <rtems_semaphore_release>        
 200dc98:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
 200dc9c:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200dca0:	80 a0 60 00 	cmp  %g1, 0                                    
 200dca4:	12 80 00 0d 	bne  200dcd8 <pipe_release+0x80>               
 200dca8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200dcac:	80 a0 60 00 	cmp  %g1, 0                                    
 200dcb0:	12 80 00 06 	bne  200dcc8 <pipe_release+0x70>               
 200dcb4:	80 a7 20 04 	cmp  %i4, 4                                    
#if 0                                                                 
    /* To delete an anonymous pipe file when all users closed it */   
    if (pipe->Anonymous)                                              
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
 200dcb8:	7f ff ff dd 	call  200dc2c <pipe_free>                      
 200dcbc:	90 10 00 1d 	mov  %i5, %o0                                  
    *pipep = NULL;                                                    
 200dcc0:	10 80 00 0e 	b  200dcf8 <pipe_release+0xa0>                 
 200dcc4:	c0 26 00 00 	clr  [ %i0 ]                                   
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
 200dcc8:	02 80 00 05 	be  200dcdc <pipe_release+0x84>                <== NEVER TAKEN
 200dccc:	80 a0 60 00 	cmp  %g1, 0                                    
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
 200dcd0:	10 80 00 08 	b  200dcf0 <pipe_release+0x98>                 
 200dcd4:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
  else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)            
 200dcd8:	80 a0 60 00 	cmp  %g1, 0                                    
 200dcdc:	12 80 00 07 	bne  200dcf8 <pipe_release+0xa0>               <== NEVER TAKEN
 200dce0:	80 a7 20 02 	cmp  %i4, 2                                    
 200dce4:	02 80 00 06 	be  200dcfc <pipe_release+0xa4>                <== NEVER TAKEN
 200dce8:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     
    PIPE_WAKEUPREADERS(pipe);                                         
 200dcec:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
 200dcf0:	40 00 06 8f 	call  200f72c <rtems_barrier_release>          
 200dcf4:	92 07 bf fc 	add  %fp, -4, %o1                              
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
 200dcf8:	03 00 80 8c 	sethi  %hi(0x2023000), %g1                     
 200dcfc:	7f ff ec df 	call  2009078 <rtems_semaphore_release>        
 200dd00:	d0 00 61 80 	ld  [ %g1 + 0x180 ], %o0	! 2023180 <pipe_semaphore>
 200dd04:	81 c7 e0 08 	ret                                            
 200dd08:	81 e8 00 00 	restore                                        
                                                                      

0200e300 <pipe_write>: pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) {
 200e300:	9d e3 bf 98 	save  %sp, -104, %sp                           
 200e304:	ba 10 00 18 	mov  %i0, %i5                                  
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
 200e308:	80 a6 a0 00 	cmp  %i2, 0                                    
 200e30c:	02 80 00 70 	be  200e4cc <pipe_write+0x1cc>                 <== NEVER TAKEN
 200e310:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
 200e314:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
 200e318:	92 10 20 00 	clr  %o1                                       
 200e31c:	7f ff eb 0e 	call  2008f54 <rtems_semaphore_obtain>         
 200e320:	94 10 20 00 	clr  %o2                                       
 200e324:	80 a2 20 00 	cmp  %o0, 0                                    
 200e328:	32 80 00 69 	bne,a   200e4cc <pipe_write+0x1cc>             <== NEVER TAKEN
 200e32c:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
    return -EINTR;                                                    
                                                                      
  if (pipe->Readers == 0) {                                           
 200e330:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200e334:	80 a0 60 00 	cmp  %g1, 0                                    
 200e338:	02 80 00 54 	be  200e488 <pipe_write+0x188>                 
 200e33c:	b8 10 3f e0 	mov  -32, %i4                                  
    ret = -EPIPE;                                                     
    goto out_locked;                                                  
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
 200e340:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 200e344:	80 a6 80 01 	cmp  %i2, %g1                                  
 200e348:	18 80 00 03 	bgu  200e354 <pipe_write+0x54>                 <== NEVER TAKEN
 200e34c:	a2 10 20 01 	mov  1, %l1                                    
 200e350:	a2 10 00 1a 	mov  %i2, %l1                                  
                                                                      
      /* Wait until there is chunk bytes space or no reader exists */ 
      pipe->waitingWriters ++;                                        
      PIPE_UNLOCK(pipe);                                              
      if (! PIPE_WRITEWAIT(pipe))                                     
        ret = -EINTR;                                                 
 200e354:	10 80 00 49 	b  200e478 <pipe_write+0x178>                  
 200e358:	b0 10 20 00 	clr  %i0                                       
  /* 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) {                                
      if (LIBIO_NODELAY(iop)) {                                       
 200e35c:	80 88 60 01 	btst  1, %g1                                   
 200e360:	32 80 00 4a 	bne,a   200e488 <pipe_write+0x188>             
 200e364:	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 ++;                                        
 200e368:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      PIPE_UNLOCK(pipe);                                              
 200e36c:	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 ++;                                        
 200e370:	82 00 60 01 	inc  %g1                                       
      PIPE_UNLOCK(pipe);                                              
 200e374:	7f ff eb 41 	call  2009078 <rtems_semaphore_release>        
 200e378:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
      if (! PIPE_WRITEWAIT(pipe))                                     
 200e37c:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
 200e380:	40 00 05 01 	call  200f784 <rtems_barrier_wait>             
 200e384:	92 10 20 00 	clr  %o1                                       
 200e388:	80 a0 00 08 	cmp  %g0, %o0                                  
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
 200e38c:	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))                                     
 200e390:	b8 60 20 00 	subx  %g0, 0, %i4                              
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
 200e394:	92 10 20 00 	clr  %o1                                       
 200e398:	94 10 20 00 	clr  %o2                                       
 200e39c:	7f ff ea ee 	call  2008f54 <rtems_semaphore_obtain>         
 200e3a0:	b8 0f 3f fc 	and  %i4, -4, %i4                              
 200e3a4:	80 a2 20 00 	cmp  %o0, 0                                    
 200e3a8:	12 80 00 43 	bne  200e4b4 <pipe_write+0x1b4>                <== NEVER TAKEN
 200e3ac:	80 a7 20 00 	cmp  %i4, 0                                    
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
 200e3b0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 200e3b4:	82 00 7f ff 	add  %g1, -1, %g1                              
      if (ret != 0)                                                   
 200e3b8:	12 80 00 34 	bne  200e488 <pipe_write+0x188>                <== NEVER TAKEN
 200e3bc:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
        goto out_locked;                                              
                                                                      
      if (pipe->Readers == 0) {                                       
 200e3c0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200e3c4:	80 a0 60 00 	cmp  %g1, 0                                    
 200e3c8:	02 80 00 30 	be  200e488 <pipe_write+0x188>                 <== NEVER TAKEN
 200e3cc:	b8 10 3f e0 	mov  -32, %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) {                                
 200e3d0:	e0 07 60 04 	ld  [ %i5 + 4 ], %l0                           
 200e3d4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 200e3d8:	b8 24 00 01 	sub  %l0, %g1, %i4                             
 200e3dc:	80 a7 00 11 	cmp  %i4, %l1                                  
 200e3e0:	2a bf ff df 	bcs,a   200e35c <pipe_write+0x5c>              
 200e3e4:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
        ret = -EPIPE;                                                 
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
 200e3e8:	84 26 80 18 	sub  %i2, %i0, %g2                             
 200e3ec:	80 a7 00 02 	cmp  %i4, %g2                                  
 200e3f0:	38 80 00 02 	bgu,a   200e3f8 <pipe_write+0xf8>              
 200e3f4:	b8 10 00 02 	mov  %g2, %i4                                  
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
 200e3f8:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
 200e3fc:	92 10 00 10 	mov  %l0, %o1                                  
 200e400:	40 00 40 b0 	call  201e6c0 <.urem>                          
 200e404:	90 00 40 08 	add  %g1, %o0, %o0                             
 200e408:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 200e40c:	a0 24 00 08 	sub  %l0, %o0, %l0                             
    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);
 200e410:	94 10 00 1c 	mov  %i4, %o2                                  
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
    if (chunk > chunk1) {                                             
 200e414:	80 a7 00 10 	cmp  %i4, %l0                                  
 200e418:	92 06 40 18 	add  %i1, %i0, %o1                             
 200e41c:	04 80 00 09 	ble  200e440 <pipe_write+0x140>                
 200e420:	90 00 40 08 	add  %g1, %o0, %o0                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
 200e424:	40 00 10 a8 	call  20126c4 <memcpy>                         
 200e428:	94 10 00 10 	mov  %l0, %o2                                  
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
 200e42c:	92 04 00 18 	add  %l0, %i0, %o1                             
 200e430:	d0 07 40 00 	ld  [ %i5 ], %o0                               
 200e434:	92 06 40 09 	add  %i1, %o1, %o1                             
 200e438:	10 80 00 02 	b  200e440 <pipe_write+0x140>                  
 200e43c:	94 27 00 10 	sub  %i4, %l0, %o2                             
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
 200e440:	40 00 10 a1 	call  20126c4 <memcpy>                         
 200e444:	01 00 00 00 	nop                                            
                                                                      
    pipe->Length += chunk;                                            
 200e448:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 200e44c:	82 00 40 1c 	add  %g1, %i4, %g1                             
 200e450:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
    if (pipe->waitingReaders > 0)                                     
 200e454:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
 200e458:	80 a0 60 00 	cmp  %g1, 0                                    
 200e45c:	22 80 00 06 	be,a   200e474 <pipe_write+0x174>              
 200e460:	b0 06 00 1c 	add  %i0, %i4, %i0                             
      PIPE_WAKEUPREADERS(pipe);                                       
 200e464:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
 200e468:	40 00 04 b1 	call  200f72c <rtems_barrier_release>          
 200e46c:	92 07 bf fc 	add  %fp, -4, %o1                              
    written += chunk;                                                 
 200e470:	b0 06 00 1c 	add  %i0, %i4, %i0                             
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
 200e474:	a2 10 20 01 	mov  1, %l1                                    
  }                                                                   
                                                                      
  /* Write of PIPE_BUF bytes or less shall not be interleaved */      
  chunk = count <= pipe->Size ? count : 1;                            
                                                                      
  while (written < count) {                                           
 200e478:	80 a6 00 1a 	cmp  %i0, %i2                                  
 200e47c:	2a bf ff d6 	bcs,a   200e3d4 <pipe_write+0xd4>              
 200e480:	e0 07 60 04 	ld  [ %i5 + 4 ], %l0                           
 200e484:	b8 10 20 00 	clr  %i4                                       
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
 200e488:	7f ff ea fc 	call  2009078 <rtems_semaphore_release>        
 200e48c:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
out_nolock:                                                           
#ifdef RTEMS_POSIX_API                                                
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
 200e490:	80 a7 3f e0 	cmp  %i4, -32                                  
 200e494:	32 80 00 0a 	bne,a   200e4bc <pipe_write+0x1bc>             
 200e498:	80 a6 20 00 	cmp  %i0, 0                                    
    kill(getpid(), SIGPIPE);                                          
 200e49c:	40 00 01 23 	call  200e928 <getpid>                         
 200e4a0:	01 00 00 00 	nop                                            
 200e4a4:	40 00 02 9b 	call  200ef10 <kill>                           
 200e4a8:	92 10 20 0d 	mov  0xd, %o1	! d <PROM_START+0xd>             
#endif                                                                
                                                                      
  if (written > 0)                                                    
 200e4ac:	10 80 00 04 	b  200e4bc <pipe_write+0x1bc>                  
 200e4b0:	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;                                                 
 200e4b4:	b8 10 3f fc 	mov  -4, %i4                                   <== NOT EXECUTED
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
#endif                                                                
                                                                      
  if (written > 0)                                                    
 200e4b8:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
 200e4bc:	14 80 00 04 	bg  200e4cc <pipe_write+0x1cc>                 
 200e4c0:	01 00 00 00 	nop                                            
 200e4c4:	81 c7 e0 08 	ret                                            
 200e4c8:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
    return written;                                                   
  return ret;                                                         
}                                                                     
 200e4cc:	81 c7 e0 08 	ret                                            
 200e4d0:	81 e8 00 00 	restore                                        
                                                                      

02007ab8 <posix_memalign>: ) { /* * Update call statistics */ MSBUMP(memalign_calls, 1);
 2007ab8:	05 00 80 90 	sethi  %hi(0x2024000), %g2                     
 2007abc:	84 10 a2 00 	or  %g2, 0x200, %g2	! 2024200 <rtems_malloc_statistics>
 2007ac0:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
 2007ac4:	86 00 e0 01 	inc  %g3                                       
 2007ac8:	c6 20 a0 08 	st  %g3, [ %g2 + 8 ]                           
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
 2007acc:	84 02 7f ff 	add  %o1, -1, %g2                              
 2007ad0:	80 88 80 09 	btst  %g2, %o1                                 
 2007ad4:	12 80 00 07 	bne  2007af0 <posix_memalign+0x38>             <== NEVER TAKEN
 2007ad8:	80 a2 60 03 	cmp  %o1, 3                                    
 2007adc:	08 80 00 05 	bleu  2007af0 <posix_memalign+0x38>            
 2007ae0:	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 );                  
 2007ae4:	82 13 c0 00 	mov  %o7, %g1                                  
 2007ae8:	40 00 00 85 	call  2007cfc <rtems_memalign>                 
 2007aec:	9e 10 40 00 	mov  %g1, %o7                                  
}                                                                     
 2007af0:	81 c3 e0 08 	retl                                           
 2007af4:	90 10 20 16 	mov  0x16, %o0                                 
                                                                      

0200c1e8 <pthread_attr_setschedpolicy>: int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) {
 200c1e8:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
 200c1ec:	80 a0 60 00 	cmp  %g1, 0                                    
 200c1f0:	02 80 00 0f 	be  200c22c <pthread_attr_setschedpolicy+0x44> 
 200c1f4:	90 10 20 16 	mov  0x16, %o0                                 
 200c1f8:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 200c1fc:	80 a0 a0 00 	cmp  %g2, 0                                    
 200c200:	02 80 00 0b 	be  200c22c <pthread_attr_setschedpolicy+0x44> 
 200c204:	80 a2 60 04 	cmp  %o1, 4                                    
    return EINVAL;                                                    
                                                                      
  switch ( policy ) {                                                 
 200c208:	38 80 00 09 	bgu,a   200c22c <pthread_attr_setschedpolicy+0x44>
 200c20c:	90 10 20 86 	mov  0x86, %o0                                 
 200c210:	84 10 20 01 	mov  1, %g2                                    
 200c214:	85 28 80 09 	sll  %g2, %o1, %g2                             
 200c218:	80 88 a0 17 	btst  0x17, %g2                                
 200c21c:	22 80 00 04 	be,a   200c22c <pthread_attr_setschedpolicy+0x44><== NEVER TAKEN
 200c220:	90 10 20 86 	mov  0x86, %o0                                 <== NOT EXECUTED
    case SCHED_OTHER:                                                 
    case SCHED_FIFO:                                                  
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      attr->schedpolicy = policy;                                     
 200c224:	d2 20 60 14 	st  %o1, [ %g1 + 0x14 ]                        
 200c228:	90 10 20 00 	clr  %o0                                       
      return 0;                                                       
                                                                      
    default:                                                          
      return ENOTSUP;                                                 
  }                                                                   
}                                                                     
 200c22c:	81 c3 e0 08 	retl                                           
                                                                      

02007940 <pthread_barrier_init>: int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) {
 2007940:	9d e3 bf 90 	save  %sp, -112, %sp                           
  const pthread_barrierattr_t   *the_attr;                            
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !barrier )                                                     
 2007944:	80 a6 20 00 	cmp  %i0, 0                                    
 2007948:	12 80 00 04 	bne  2007958 <pthread_barrier_init+0x18>       
 200794c:	80 a6 a0 00 	cmp  %i2, 0                                    
  switch ( the_attr->process_shared ) {                               
    case PTHREAD_PROCESS_PRIVATE:    /* only supported values */      
      break;                                                          
    case PTHREAD_PROCESS_SHARED:                                      
    default:                                                          
      return EINVAL;                                                  
 2007950:	81 c7 e0 08 	ret                                            
 2007954:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
   *  Error check parameters                                          
   */                                                                 
  if ( !barrier )                                                     
    return EINVAL;                                                    
                                                                      
  if ( count == 0 )                                                   
 2007958:	22 80 00 1e 	be,a   20079d0 <pthread_barrier_init+0x90>     
 200795c:	b0 10 20 16 	mov  0x16, %i0                                 
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
 2007960:	80 a6 60 00 	cmp  %i1, 0                                    
 2007964:	32 80 00 06 	bne,a   200797c <pthread_barrier_init+0x3c>    
 2007968:	c2 06 40 00 	ld  [ %i1 ], %g1                               
    the_attr = attr;                                                  
  } else {                                                            
    (void) pthread_barrierattr_init( &my_attr );                      
 200796c:	90 07 bf f8 	add  %fp, -8, %o0                              
 2007970:	7f ff ff bc 	call  2007860 <pthread_barrierattr_init>       
 2007974:	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 )                                    
 2007978:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 200797c:	80 a0 60 00 	cmp  %g1, 0                                    
 2007980:	22 80 00 14 	be,a   20079d0 <pthread_barrier_init+0x90>     
 2007984:	b0 10 20 16 	mov  0x16, %i0                                 
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
 2007988:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 200798c:	80 a0 60 00 	cmp  %g1, 0                                    
 2007990:	32 80 00 10 	bne,a   20079d0 <pthread_barrier_init+0x90>    <== NEVER TAKEN
 2007994:	b0 10 20 16 	mov  0x16, %i0                                 <== 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;                  
 2007998:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
 200799c:	c4 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g2	! 201ebe0 <_Thread_Dispatch_disable_level>
  }                                                                   
                                                                      
  /*                                                                  
   * Convert from POSIX attributes to Core Barrier attributes         
   */                                                                 
  the_attributes.discipline    = CORE_BARRIER_AUTOMATIC_RELEASE;      
 20079a0:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  the_attributes.maximum_count = count;                               
 20079a4:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
                                                                      
    ++level;                                                          
 20079a8:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 20079ac:	c4 20 63 e0 	st  %g2, [ %g1 + 0x3e0 ]                       
 *  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 *)                                    
 20079b0:	39 00 80 7b 	sethi  %hi(0x201ec00), %i4                     
 20079b4:	40 00 08 7a 	call  2009b9c <_Objects_Allocate>              
 20079b8:	90 17 23 74 	or  %i4, 0x374, %o0	! 201ef74 <_POSIX_Barrier_Information>
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _POSIX_Barrier_Allocate();                            
                                                                      
  if ( !the_barrier ) {                                               
 20079bc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20079c0:	12 80 00 06 	bne  20079d8 <pthread_barrier_init+0x98>       
 20079c4:	90 07 60 10 	add  %i5, 0x10, %o0                            
    _Thread_Enable_dispatch();                                        
 20079c8:	40 00 0d 73 	call  200af94 <_Thread_Enable_dispatch>        
 20079cc:	b0 10 20 0b 	mov  0xb, %i0                                  
 20079d0:	81 c7 e0 08 	ret                                            
 20079d4:	81 e8 00 00 	restore                                        
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
 20079d8:	40 00 05 ee 	call  2009190 <_CORE_barrier_Initialize>       
 20079dc:	92 07 bf f0 	add  %fp, -16, %o1                             
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 20079e0:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 20079e4:	b8 17 23 74 	or  %i4, 0x374, %i4                            
 20079e8:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 20079ec:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 20079f0:	85 28 a0 02 	sll  %g2, 2, %g2                               
 20079f4:	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;                                   
 20079f8:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
  );                                                                  
                                                                      
  /*                                                                  
   * Exit the critical section and return the user an operational barrier
   */                                                                 
  *barrier = the_barrier->Object.id;                                  
 20079fc:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  _Thread_Enable_dispatch();                                          
 2007a00:	40 00 0d 65 	call  200af94 <_Thread_Enable_dispatch>        
 2007a04:	b0 10 20 00 	clr  %i0                                       
 2007a08:	81 c7 e0 08 	ret                                            
 2007a0c:	81 e8 00 00 	restore                                        
                                                                      

02007230 <pthread_cleanup_push>: void pthread_cleanup_push( void (*routine)( void * ), void *arg ) {
 2007230:	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 )                                                     
 2007234:	80 a6 20 00 	cmp  %i0, 0                                    
 2007238:	02 80 00 12 	be  2007280 <pthread_cleanup_push+0x50>        
 200723c:	03 00 80 79 	sethi  %hi(0x201e400), %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;                  
 2007240:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2	! 201e420 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 2007244:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2007248:	c4 20 60 20 	st  %g2, [ %g1 + 0x20 ]                        
    return;                                                           
                                                                      
  _Thread_Disable_dispatch();                                         
  handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
 200724c:	40 00 11 f8 	call  200ba2c <_Workspace_Allocate>            
 2007250:	90 10 20 10 	mov  0x10, %o0                                 
                                                                      
  if ( handler ) {                                                    
 2007254:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2007258:	02 80 00 08 	be  2007278 <pthread_cleanup_push+0x48>        <== NEVER TAKEN
 200725c:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
    thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
 2007260:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1	! 201e950 <_Per_CPU_Information+0x10>
                                                                      
    handler_stack = &thread_support->Cancellation_Handlers;           
 2007264:	d0 00 61 5c 	ld  [ %g1 + 0x15c ], %o0                       
                                                                      
    handler->routine = routine;                                       
 2007268:	f0 22 60 08 	st  %i0, [ %o1 + 8 ]                           
    handler->arg = arg;                                               
 200726c:	f2 22 60 0c 	st  %i1, [ %o1 + 0xc ]                         
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
 2007270:	40 00 06 30 	call  2008b30 <_Chain_Append>                  
 2007274:	90 02 20 e4 	add  %o0, 0xe4, %o0                            
  }                                                                   
  _Thread_Enable_dispatch();                                          
 2007278:	40 00 0d ab 	call  200a924 <_Thread_Enable_dispatch>        
 200727c:	81 e8 00 00 	restore                                        
 2007280:	81 c7 e0 08 	ret                                            
 2007284:	81 e8 00 00 	restore                                        
                                                                      

02008210 <pthread_cond_init>: */ int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) {
 2008210:	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;                                        
 2008214:	80 a6 60 00 	cmp  %i1, 0                                    
 2008218:	32 80 00 05 	bne,a   200822c <pthread_cond_init+0x1c>       
 200821c:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
  else        the_attr = &_POSIX_Condition_variables_Default_attributes;
 2008220:	33 00 80 77 	sethi  %hi(0x201dc00), %i1                     
 2008224:	b2 16 60 cc 	or  %i1, 0xcc, %i1	! 201dccc <_POSIX_Condition_variables_Default_attributes>
                                                                      
  /*                                                                  
   *  Be careful about attributes when global!!!                      
   */                                                                 
  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )           
 2008228:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
 200822c:	80 a0 a0 01 	cmp  %g2, 1                                    
 2008230:	02 80 00 25 	be  20082c4 <pthread_cond_init+0xb4>           <== NEVER TAKEN
 2008234:	82 10 20 16 	mov  0x16, %g1                                 
    return EINVAL;                                                    
                                                                      
  if ( !the_attr->is_initialized )                                    
 2008238:	c4 06 40 00 	ld  [ %i1 ], %g2                               
 200823c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2008240:	02 80 00 21 	be  20082c4 <pthread_cond_init+0xb4>           
 2008244:	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;                  
 2008248:	03 00 80 7f 	sethi  %hi(0x201fc00), %g1                     
 200824c:	c4 00 62 50 	ld  [ %g1 + 0x250 ], %g2	! 201fe50 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 2008250:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2008254:	c4 20 62 50 	st  %g2, [ %g1 + 0x250 ]                       
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control                
  *_POSIX_Condition_variables_Allocate( void )                        
{                                                                     
  return (POSIX_Condition_variables_Control *)                        
 2008258:	39 00 80 80 	sethi  %hi(0x2020000), %i4                     
 200825c:	40 00 0a 23 	call  200aae8 <_Objects_Allocate>              
 2008260:	90 17 22 7c 	or  %i4, 0x27c, %o0	! 202027c <_POSIX_Condition_variables_Information>
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_cond = _POSIX_Condition_variables_Allocate();                   
                                                                      
  if ( !the_cond ) {                                                  
 2008264:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2008268:	32 80 00 06 	bne,a   2008280 <pthread_cond_init+0x70>       
 200826c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
    _Thread_Enable_dispatch();                                        
 2008270:	40 00 0f 1c 	call  200bee0 <_Thread_Enable_dispatch>        
 2008274:	01 00 00 00 	nop                                            
    return ENOMEM;                                                    
 2008278:	10 80 00 13 	b  20082c4 <pthread_cond_init+0xb4>            
 200827c:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
                                                                      
  _Thread_queue_Initialize(                                           
 2008280:	90 07 60 18 	add  %i5, 0x18, %o0                            
  if ( !the_cond ) {                                                  
    _Thread_Enable_dispatch();                                        
    return ENOMEM;                                                    
  }                                                                   
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
 2008284:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
                                                                      
  _Thread_queue_Initialize(                                           
 2008288:	92 10 20 00 	clr  %o1                                       
 200828c:	15 04 00 02 	sethi  %hi(0x10000800), %o2                    
 2008290:	96 10 20 74 	mov  0x74, %o3                                 
 2008294:	40 00 11 19 	call  200c6f8 <_Thread_queue_Initialize>       
 2008298:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 200829c:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 20082a0:	b8 17 22 7c 	or  %i4, 0x27c, %i4                            
 20082a4:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 20082a8:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 20082ac:	85 28 a0 02 	sll  %g2, 2, %g2                               
 20082b0:	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;                                   
 20082b4:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    0                                                                 
  );                                                                  
                                                                      
  *cond = the_cond->Object.id;                                        
                                                                      
  _Thread_Enable_dispatch();                                          
 20082b8:	40 00 0f 0a 	call  200bee0 <_Thread_Enable_dispatch>        
 20082bc:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  return 0;                                                           
 20082c0:	82 10 20 00 	clr  %g1                                       
}                                                                     
 20082c4:	81 c7 e0 08 	ret                                            
 20082c8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02008070 <pthread_condattr_destroy>: */ int pthread_condattr_destroy( pthread_condattr_t *attr ) {
 2008070:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || attr->is_initialized == false )                       
 2008074:	80 a0 60 00 	cmp  %g1, 0                                    
 2008078:	02 80 00 08 	be  2008098 <pthread_condattr_destroy+0x28>    
 200807c:	90 10 20 16 	mov  0x16, %o0                                 
 2008080:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 2008084:	80 a0 a0 00 	cmp  %g2, 0                                    
 2008088:	02 80 00 04 	be  2008098 <pthread_condattr_destroy+0x28>    <== NEVER TAKEN
 200808c:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  attr->is_initialized = false;                                       
 2008090:	c0 20 40 00 	clr  [ %g1 ]                                   
  return 0;                                                           
 2008094:	90 10 20 00 	clr  %o0                                       
}                                                                     
 2008098:	81 c3 e0 08 	retl                                           
                                                                      

02007608 <pthread_create>: pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) {
 2007608:	9d e3 bf 58 	save  %sp, -168, %sp                           
  int                                 schedpolicy = SCHED_RR;         
  struct sched_param                  schedparam;                     
  Objects_Name                        name;                           
  int                                 rc;                             
                                                                      
  if ( !start_routine )                                               
 200760c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2007610:	02 80 00 8c 	be  2007840 <pthread_create+0x238>             
 2007614:	ba 10 20 0e 	mov  0xe, %i5                                  
    return EFAULT;                                                    
                                                                      
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;      
 2007618:	80 a6 60 00 	cmp  %i1, 0                                    
 200761c:	32 80 00 05 	bne,a   2007630 <pthread_create+0x28>          
 2007620:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2007624:	33 00 80 80 	sethi  %hi(0x2020000), %i1                     
 2007628:	b2 16 62 74 	or  %i1, 0x274, %i1	! 2020274 <_POSIX_Threads_Default_attributes>
                                                                      
  if ( !the_attr->is_initialized )                                    
 200762c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2007630:	80 a0 60 00 	cmp  %g1, 0                                    
 2007634:	02 80 00 83 	be  2007840 <pthread_create+0x238>             
 2007638:	ba 10 20 16 	mov  0x16, %i5                                 
   *  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) )
 200763c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 2007640:	80 a0 60 00 	cmp  %g1, 0                                    
 2007644:	02 80 00 07 	be  2007660 <pthread_create+0x58>              
 2007648:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200764c:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
 2007650:	c2 00 63 70 	ld  [ %g1 + 0x370 ], %g1                       
 2007654:	80 a0 80 01 	cmp  %g2, %g1                                  
 2007658:	2a 80 00 7b 	bcs,a   2007844 <pthread_create+0x23c>         
 200765c:	b0 10 00 1d 	mov  %i5, %i0                                  
   *  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 ) {                                 
 2007660:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 2007664:	80 a0 60 01 	cmp  %g1, 1                                    
 2007668:	02 80 00 06 	be  2007680 <pthread_create+0x78>              
 200766c:	80 a0 60 02 	cmp  %g1, 2                                    
 2007670:	32 80 00 74 	bne,a   2007840 <pthread_create+0x238>         
 2007674:	ba 10 20 16 	mov  0x16, %i5                                 
      schedpolicy = api->schedpolicy;                                 
      schedparam  = api->schedparam;                                  
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
 2007678:	10 80 00 09 	b  200769c <pthread_create+0x94>               
 200767c:	e2 06 60 14 	ld  [ %i1 + 0x14 ], %l1                        
   *  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 ];    
 2007680:	03 00 80 8a 	sethi  %hi(0x2022800), %g1                     
 2007684:	c2 00 61 30 	ld  [ %g1 + 0x130 ], %g1	! 2022930 <_Per_CPU_Information+0x10>
      schedpolicy = api->schedpolicy;                                 
      schedparam  = api->schedparam;                                  
 2007688:	90 07 bf e4 	add  %fp, -28, %o0                             
   *  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 ];    
 200768c:	d2 00 61 5c 	ld  [ %g1 + 0x15c ], %o1                       
      schedpolicy = api->schedpolicy;                                 
 2007690:	e2 02 60 84 	ld  [ %o1 + 0x84 ], %l1                        
      schedparam  = api->schedparam;                                  
 2007694:	10 80 00 04 	b  20076a4 <pthread_create+0x9c>               
 2007698:	92 02 60 88 	add  %o1, 0x88, %o1                            
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
      schedparam  = the_attr->schedparam;                             
 200769c:	90 07 bf e4 	add  %fp, -28, %o0                             
 20076a0:	92 06 60 18 	add  %i1, 0x18, %o1                            
 20076a4:	40 00 25 72 	call  2010c6c <memcpy>                         
 20076a8:	94 10 20 1c 	mov  0x1c, %o2                                 
                                                                      
  /*                                                                  
   *  Check the contentionscope since rtems only supports PROCESS wide
   *  contention (i.e. no system wide contention).                    
   */                                                                 
  if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )           
 20076ac:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
 20076b0:	80 a0 60 00 	cmp  %g1, 0                                    
 20076b4:	12 80 00 63 	bne  2007840 <pthread_create+0x238>            
 20076b8:	ba 10 20 86 	mov  0x86, %i5                                 
    return ENOTSUP;                                                   
                                                                      
  /*                                                                  
   *  Interpret the scheduling parameters.                            
   */                                                                 
  if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )       
 20076bc:	40 00 19 09 	call  200dae0 <_POSIX_Priority_Is_valid>       
 20076c0:	d0 07 bf e4 	ld  [ %fp + -28 ], %o0                         
 20076c4:	80 8a 20 ff 	btst  0xff, %o0                                
 20076c8:	02 80 00 5e 	be  2007840 <pthread_create+0x238>             <== NEVER TAKEN
 20076cc:	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);
 20076d0:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    return EINVAL;                                                    
                                                                      
  core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
 20076d4:	e4 07 bf e4 	ld  [ %fp + -28 ], %l2                         
 20076d8:	e6 08 63 6c 	ldub  [ %g1 + 0x36c ], %l3                     
                                                                      
  /*                                                                  
   *  Set the core scheduling policy information.                     
   */                                                                 
  rc = _POSIX_Thread_Translate_sched_param(                           
 20076dc:	90 10 00 11 	mov  %l1, %o0                                  
 20076e0:	92 07 bf e4 	add  %fp, -28, %o1                             
 20076e4:	94 07 bf dc 	add  %fp, -36, %o2                             
 20076e8:	40 00 19 09 	call  200db0c <_POSIX_Thread_Translate_sched_param>
 20076ec:	96 07 bf e0 	add  %fp, -32, %o3                             
    schedpolicy,                                                      
    &schedparam,                                                      
    &budget_algorithm,                                                
    &budget_callout                                                   
  );                                                                  
  if ( rc )                                                           
 20076f0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20076f4:	32 80 00 54 	bne,a   2007844 <pthread_create+0x23c>         
 20076f8:	b0 10 00 1d 	mov  %i5, %i0                                  
  #endif                                                              
                                                                      
  /*                                                                  
   *  Lock the allocator mutex for protection                         
   */                                                                 
  _RTEMS_Lock_allocator();                                            
 20076fc:	39 00 80 89 	sethi  %hi(0x2022400), %i4                     
 2007700:	40 00 06 48 	call  2009020 <_API_Mutex_Lock>                
 2007704:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0	! 2022484 <_RTEMS_Allocator_Mutex>
 *  _POSIX_Threads_Allocate                                           
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )  
{                                                                     
  return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
 2007708:	11 00 80 89 	sethi  %hi(0x2022400), %o0                     
 200770c:	40 00 08 e4 	call  2009a9c <_Objects_Allocate>              
 2007710:	90 12 22 14 	or  %o0, 0x214, %o0	! 2022614 <_POSIX_Threads_Information>
   *  Allocate the thread control block.                              
   *                                                                  
   *  NOTE:  Global threads are not currently supported.              
   */                                                                 
  the_thread = _POSIX_Threads_Allocate();                             
  if ( !the_thread ) {                                                
 2007714:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2007718:	32 80 00 04 	bne,a   2007728 <pthread_create+0x120>         
 200771c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    _RTEMS_Unlock_allocator();                                        
 2007720:	10 80 00 21 	b  20077a4 <pthread_create+0x19c>              
 2007724:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        
                                                                      
static inline size_t _POSIX_Threads_Ensure_minimum_stack (            
  size_t size                                                         
)                                                                     
{                                                                     
  if ( size >= PTHREAD_MINIMUM_STACK_SIZE )                           
 2007728:	05 00 80 85 	sethi  %hi(0x2021400), %g2                     
 200772c:	d6 00 a3 70 	ld  [ %g2 + 0x370 ], %o3	! 2021770 <rtems_minimum_stack_size>
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
  name.name_p = NULL;   /* posix threads don't have a name by default */
  status = _Thread_Initialize(                                        
 2007730:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
 2007734:	97 2a e0 01 	sll  %o3, 1, %o3                               
 2007738:	80 a2 c0 01 	cmp  %o3, %g1                                  
 200773c:	1a 80 00 03 	bcc  2007748 <pthread_create+0x140>            
 2007740:	d4 06 60 04 	ld  [ %i1 + 4 ], %o2                           
 2007744:	96 10 00 01 	mov  %g1, %o3                                  
 2007748:	82 10 20 01 	mov  1, %g1                                    
 200774c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 2007750:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 2007754:	9a 0c e0 ff 	and  %l3, 0xff, %o5                            
 2007758:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
 200775c:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
 2007760:	c0 23 a0 68 	clr  [ %sp + 0x68 ]                            
 2007764:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
 2007768:	82 07 bf d4 	add  %fp, -44, %g1                             
 200776c:	39 00 80 89 	sethi  %hi(0x2022400), %i4                     
 2007770:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
 2007774:	90 17 22 14 	or  %i4, 0x214, %o0                            
 2007778:	92 10 00 10 	mov  %l0, %o1                                  
 200777c:	98 10 20 01 	mov  1, %o4                                    
 2007780:	40 00 0d fd 	call  200af74 <_Thread_Initialize>             
 2007784:	9a 23 40 12 	sub  %o5, %l2, %o5                             
    budget_callout,                                                   
    0,                    /* isr level */                             
    name                  /* posix threads don't have a name */       
  );                                                                  
                                                                      
  if ( !status ) {                                                    
 2007788:	80 8a 20 ff 	btst  0xff, %o0                                
 200778c:	12 80 00 0a 	bne  20077b4 <pthread_create+0x1ac>            
 2007790:	90 17 22 14 	or  %i4, 0x214, %o0                            
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (                       
  Thread_Control *the_pthread                                         
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 
 2007794:	40 00 09 a1 	call  2009e18 <_Objects_Free>                  
 2007798:	92 10 00 10 	mov  %l0, %o1                                  
    _POSIX_Threads_Free( the_thread );                                
    _RTEMS_Unlock_allocator();                                        
 200779c:	03 00 80 89 	sethi  %hi(0x2022400), %g1                     
 20077a0:	d0 00 60 84 	ld  [ %g1 + 0x84 ], %o0	! 2022484 <_RTEMS_Allocator_Mutex>
 20077a4:	40 00 06 34 	call  2009074 <_API_Mutex_Unlock>              
 20077a8:	ba 10 20 0b 	mov  0xb, %i5                                  
   */                                                                 
  *thread = the_thread->Object.id;                                    
                                                                      
  _RTEMS_Unlock_allocator();                                          
  return 0;                                                           
}                                                                     
 20077ac:	81 c7 e0 08 	ret                                            
 20077b0:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  }                                                                   
                                                                      
  /*                                                                  
   *  finish initializing the per API structure                       
   */                                                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
 20077b4:	f8 04 21 5c 	ld  [ %l0 + 0x15c ], %i4                       
                                                                      
  api->Attributes  = *the_attr;                                       
 20077b8:	92 10 00 19 	mov  %i1, %o1                                  
 20077bc:	94 10 20 40 	mov  0x40, %o2                                 
 20077c0:	40 00 25 2b 	call  2010c6c <memcpy>                         
 20077c4:	90 10 00 1c 	mov  %i4, %o0                                  
  api->detachstate = the_attr->detachstate;                           
 20077c8:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
  api->schedpolicy = schedpolicy;                                     
  api->schedparam  = schedparam;                                      
 20077cc:	92 07 bf e4 	add  %fp, -28, %o1                             
   *  finish initializing the per API structure                       
   */                                                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
                                                                      
  api->Attributes  = *the_attr;                                       
  api->detachstate = the_attr->detachstate;                           
 20077d0:	c2 27 20 40 	st  %g1, [ %i4 + 0x40 ]                        
  api->schedpolicy = schedpolicy;                                     
  api->schedparam  = schedparam;                                      
 20077d4:	94 10 20 1c 	mov  0x1c, %o2                                 
   */                                                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
                                                                      
  api->Attributes  = *the_attr;                                       
  api->detachstate = the_attr->detachstate;                           
  api->schedpolicy = schedpolicy;                                     
 20077d8:	e2 27 20 84 	st  %l1, [ %i4 + 0x84 ]                        
  api->schedparam  = schedparam;                                      
 20077dc:	40 00 25 24 	call  2010c6c <memcpy>                         
 20077e0:	90 07 20 88 	add  %i4, 0x88, %o0                            
                                                                      
  /*                                                                  
   *  POSIX threads are allocated and started in one operation.       
   */                                                                 
  status = _Thread_Start(                                             
 20077e4:	90 10 00 10 	mov  %l0, %o0                                  
 20077e8:	92 10 20 01 	mov  1, %o1                                    
 20077ec:	94 10 00 1a 	mov  %i2, %o2                                  
 20077f0:	96 10 00 1b 	mov  %i3, %o3                                  
 20077f4:	40 00 10 2f 	call  200b8b0 <_Thread_Start>                  
 20077f8:	98 10 20 00 	clr  %o4                                       
      _RTEMS_Unlock_allocator();                                      
      return EINVAL;                                                  
    }                                                                 
  #endif                                                              
                                                                      
  if ( schedpolicy == SCHED_SPORADIC ) {                              
 20077fc:	80 a4 60 04 	cmp  %l1, 4                                    
 2007800:	32 80 00 0a 	bne,a   2007828 <pthread_create+0x220>         
 2007804:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
    _Watchdog_Insert_ticks(                                           
 2007808:	40 00 10 54 	call  200b958 <_Timespec_To_ticks>             
 200780c:	90 07 20 90 	add  %i4, 0x90, %o0                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2007810:	92 07 20 a8 	add  %i4, 0xa8, %o1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 2007814:	d0 27 20 b4 	st  %o0, [ %i4 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2007818:	11 00 80 89 	sethi  %hi(0x2022400), %o0                     
 200781c:	40 00 11 04 	call  200bc2c <_Watchdog_Insert>               
 2007820:	90 12 20 9c 	or  %o0, 0x9c, %o0	! 202249c <_Watchdog_Ticks_chain>
  }                                                                   
                                                                      
  /*                                                                  
   *  Return the id and indicate we successfully created the thread   
   */                                                                 
  *thread = the_thread->Object.id;                                    
 2007824:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
 2007828:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  _RTEMS_Unlock_allocator();                                          
 200782c:	03 00 80 89 	sethi  %hi(0x2022400), %g1                     
 2007830:	40 00 06 11 	call  2009074 <_API_Mutex_Unlock>              
 2007834:	d0 00 60 84 	ld  [ %g1 + 0x84 ], %o0	! 2022484 <_RTEMS_Allocator_Mutex>
  return 0;                                                           
}                                                                     
 2007838:	81 c7 e0 08 	ret                                            
 200783c:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
 2007840:	b0 10 00 1d 	mov  %i5, %i0                                  
 2007844:	81 c7 e0 08 	ret                                            
 2007848:	81 e8 00 00 	restore                                        
                                                                      

0201a3f4 <pthread_kill>: int pthread_kill( pthread_t thread, int sig ) {
 201a3f4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  POSIX_API_Control  *api;                                            
  Thread_Control     *the_thread;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !sig )                                                         
 201a3f8:	80 a6 60 00 	cmp  %i1, 0                                    
 201a3fc:	32 80 00 03 	bne,a   201a408 <pthread_kill+0x14>            
 201a400:	b8 06 7f ff 	add  %i1, -1, %i4                              
 201a404:	30 80 00 04 	b,a   201a414 <pthread_kill+0x20>              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
 201a408:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
 201a40c:	28 80 00 06 	bleu,a   201a424 <pthread_kill+0x30>           
 201a410:	90 10 00 18 	mov  %i0, %o0                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
 201a414:	7f ff d4 96 	call  200f66c <__errno>                        
 201a418:	01 00 00 00 	nop                                            
 201a41c:	10 80 00 30 	b  201a4dc <pthread_kill+0xe8>                 
 201a420:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
                                                                      
  the_thread = _Thread_Get( thread, &location );                      
 201a424:	7f ff bf 17 	call  200a080 <_Thread_Get>                    
 201a428:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 201a42c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 201a430:	80 a0 60 00 	cmp  %g1, 0                                    
 201a434:	12 80 00 27 	bne  201a4d0 <pthread_kill+0xdc>               <== NEVER TAKEN
 201a438:	ba 10 00 08 	mov  %o0, %i5                                  
 201a43c:	11 00 80 72 	sethi  %hi(0x201c800), %o0                     
 201a440:	7f ff b7 04 	call  2008050 <_API_extensions_Add_post_switch>
 201a444:	90 12 23 a4 	or  %o0, 0x3a4, %o0	! 201cba4 <_POSIX_signals_Post_switch>
                                                                      
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
                                                                      
      if ( sig ) {                                                    
                                                                      
        if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {  
 201a448:	85 2e 60 02 	sll  %i1, 2, %g2                               
 201a44c:	87 2e 60 04 	sll  %i1, 4, %g3                               
 201a450:	86 20 c0 02 	sub  %g3, %g2, %g3                             
 201a454:	05 00 80 76 	sethi  %hi(0x201d800), %g2                     
 201a458:	84 10 a3 50 	or  %g2, 0x350, %g2	! 201db50 <_POSIX_signals_Vectors>
 201a45c:	84 00 80 03 	add  %g2, %g3, %g2                             
 201a460:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
 201a464:	80 a0 a0 01 	cmp  %g2, 1                                    
 201a468:	12 80 00 06 	bne  201a480 <pthread_kill+0x8c>               
 201a46c:	c2 07 61 5c 	ld  [ %i5 + 0x15c ], %g1                       
          _Thread_Enable_dispatch();                                  
 201a470:	7f ff be f8 	call  200a050 <_Thread_Enable_dispatch>        
 201a474:	b0 10 20 00 	clr  %i0                                       
 201a478:	81 c7 e0 08 	ret                                            
 201a47c:	81 e8 00 00 	restore                                        
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
 201a480:	c4 00 60 d4 	ld  [ %g1 + 0xd4 ], %g2                        
 201a484:	b6 10 20 01 	mov  1, %i3                                    
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
 201a488:	90 10 00 1d 	mov  %i5, %o0                                  
 201a48c:	b9 2e c0 1c 	sll  %i3, %i4, %i4                             
 201a490:	92 10 00 19 	mov  %i1, %o1                                  
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
 201a494:	b8 10 80 1c 	or  %g2, %i4, %i4                              
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
 201a498:	94 10 20 00 	clr  %o2                                       
 201a49c:	7f ff ff 84 	call  201a2ac <_POSIX_signals_Unblock_thread>  
 201a4a0:	f8 20 60 d4 	st  %i4, [ %g1 + 0xd4 ]                        
                                                                      
        if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
 201a4a4:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 201a4a8:	82 10 62 f0 	or  %g1, 0x2f0, %g1	! 201daf0 <_Per_CPU_Information>
 201a4ac:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 201a4b0:	80 a0 a0 00 	cmp  %g2, 0                                    
 201a4b4:	02 bf ff ef 	be  201a470 <pthread_kill+0x7c>                
 201a4b8:	01 00 00 00 	nop                                            
 201a4bc:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 201a4c0:	80 a7 40 02 	cmp  %i5, %g2                                  
 201a4c4:	22 bf ff eb 	be,a   201a470 <pthread_kill+0x7c>             
 201a4c8:	f6 28 60 0c 	stb  %i3, [ %g1 + 0xc ]                        
 201a4cc:	30 bf ff e9 	b,a   201a470 <pthread_kill+0x7c>              
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( ESRCH );                      
 201a4d0:	7f ff d4 67 	call  200f66c <__errno>                        <== NOT EXECUTED
 201a4d4:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201a4d8:	82 10 20 03 	mov  3, %g1	! 3 <PROM_START+0x3>               <== NOT EXECUTED
 201a4dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
 201a4e0:	81 c7 e0 08 	ret                                            
 201a4e4:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

020097e4 <pthread_mutex_timedlock>: */ int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) {
 20097e4:	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 );       
 20097e8:	92 07 bf fc 	add  %fp, -4, %o1                              
 20097ec:	40 00 00 37 	call  20098c8 <_POSIX_Absolute_timeout_to_ticks>
 20097f0:	90 10 00 19 	mov  %i1, %o0                                  
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );   
 20097f4:	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 )                
 20097f8:	82 1a 20 03 	xor  %o0, 3, %g1                               
 20097fc:	80 a0 00 01 	cmp  %g0, %g1                                  
   *                                                                  
   *  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 );       
 2009800:	ba 10 00 08 	mov  %o0, %i5                                  
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
 2009804:	b8 60 3f ff 	subx  %g0, -1, %i4                             
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );   
 2009808:	90 10 00 18 	mov  %i0, %o0                                  
 200980c:	7f ff ff b7 	call  20096e8 <_POSIX_Mutex_Lock_support>      
 2009810:	92 10 00 1c 	mov  %i4, %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) ) {                         
 2009814:	80 a7 20 00 	cmp  %i4, 0                                    
 2009818:	12 80 00 0c 	bne  2009848 <pthread_mutex_timedlock+0x64>    
 200981c:	b0 10 00 08 	mov  %o0, %i0                                  
 2009820:	80 a2 20 10 	cmp  %o0, 0x10                                 
 2009824:	12 80 00 09 	bne  2009848 <pthread_mutex_timedlock+0x64>    
 2009828:	80 a7 60 00 	cmp  %i5, 0                                    
    if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                   
 200982c:	02 80 00 07 	be  2009848 <pthread_mutex_timedlock+0x64>     <== NEVER TAKEN
 2009830:	b0 10 20 16 	mov  0x16, %i0                                 
      return EINVAL;                                                  
    if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||               
 2009834:	ba 07 7f ff 	add  %i5, -1, %i5                              
 2009838:	80 a7 60 01 	cmp  %i5, 1                                    
 200983c:	18 80 00 03 	bgu  2009848 <pthread_mutex_timedlock+0x64>    <== NEVER TAKEN
 2009840:	b0 10 20 10 	mov  0x10, %i0                                 
         status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                    
      return ETIMEDOUT;                                               
 2009844:	b0 10 20 74 	mov  0x74, %i0                                 
  }                                                                   
                                                                      
  return lock_status;                                                 
}                                                                     
 2009848:	81 c7 e0 08 	ret                                            
 200984c:	81 e8 00 00 	restore                                        
                                                                      

02006eec <pthread_mutexattr_gettype>: #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_gettype( const pthread_mutexattr_t *attr, int *type ) {
 2006eec:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr )                                                        
 2006ef0:	80 a0 60 00 	cmp  %g1, 0                                    
 2006ef4:	02 80 00 0b 	be  2006f20 <pthread_mutexattr_gettype+0x34>   
 2006ef8:	90 10 20 16 	mov  0x16, %o0                                 
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
 2006efc:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 2006f00:	80 a0 a0 00 	cmp  %g2, 0                                    
 2006f04:	02 80 00 07 	be  2006f20 <pthread_mutexattr_gettype+0x34>   
 2006f08:	80 a2 60 00 	cmp  %o1, 0                                    
    return EINVAL;                                                    
                                                                      
  if ( !type )                                                        
 2006f0c:	02 80 00 05 	be  2006f20 <pthread_mutexattr_gettype+0x34>   <== NEVER TAKEN
 2006f10:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  *type = attr->type;                                                 
 2006f14:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
  return 0;                                                           
 2006f18:	90 10 20 00 	clr  %o0                                       
    return EINVAL;                                                    
                                                                      
  if ( !type )                                                        
    return EINVAL;                                                    
                                                                      
  *type = attr->type;                                                 
 2006f1c:	c2 22 40 00 	st  %g1, [ %o1 ]                               
  return 0;                                                           
}                                                                     
 2006f20:	81 c3 e0 08 	retl                                           
                                                                      

0200939c <pthread_mutexattr_setpshared>: int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) {
 200939c:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
 20093a0:	80 a0 60 00 	cmp  %g1, 0                                    
 20093a4:	02 80 00 0a 	be  20093cc <pthread_mutexattr_setpshared+0x30>
 20093a8:	90 10 20 16 	mov  0x16, %o0                                 
 20093ac:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 20093b0:	80 a0 a0 00 	cmp  %g2, 0                                    
 20093b4:	02 80 00 06 	be  20093cc <pthread_mutexattr_setpshared+0x30>
 20093b8:	80 a2 60 01 	cmp  %o1, 1                                    
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
 20093bc:	18 80 00 04 	bgu  20093cc <pthread_mutexattr_setpshared+0x30><== NEVER TAKEN
 20093c0:	01 00 00 00 	nop                                            
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
 20093c4:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      return 0;                                                       
 20093c8:	90 10 20 00 	clr  %o0                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
 20093cc:	81 c3 e0 08 	retl                                           
                                                                      

02006f58 <pthread_mutexattr_settype>: #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) {
 2006f58:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
 2006f5c:	80 a0 60 00 	cmp  %g1, 0                                    
 2006f60:	02 80 00 0a 	be  2006f88 <pthread_mutexattr_settype+0x30>   
 2006f64:	90 10 20 16 	mov  0x16, %o0                                 
 2006f68:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 2006f6c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2006f70:	02 80 00 06 	be  2006f88 <pthread_mutexattr_settype+0x30>   <== NEVER TAKEN
 2006f74:	80 a2 60 03 	cmp  %o1, 3                                    
    return EINVAL;                                                    
                                                                      
  switch ( type ) {                                                   
 2006f78:	18 80 00 04 	bgu  2006f88 <pthread_mutexattr_settype+0x30>  
 2006f7c:	01 00 00 00 	nop                                            
    case PTHREAD_MUTEX_NORMAL:                                        
    case PTHREAD_MUTEX_RECURSIVE:                                     
    case PTHREAD_MUTEX_ERRORCHECK:                                    
    case PTHREAD_MUTEX_DEFAULT:                                       
      attr->type = type;                                              
 2006f80:	d2 20 60 10 	st  %o1, [ %g1 + 0x10 ]                        
      return 0;                                                       
 2006f84:	90 10 20 00 	clr  %o0                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
 2006f88:	81 c3 e0 08 	retl                                           
                                                                      

02007c90 <pthread_once>: int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) {
 2007c90:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !once_control || !init_routine )                               
 2007c94:	80 a6 60 00 	cmp  %i1, 0                                    
 2007c98:	02 80 00 1c 	be  2007d08 <pthread_once+0x78>                
 2007c9c:	ba 10 00 18 	mov  %i0, %i5                                  
 2007ca0:	80 a6 20 00 	cmp  %i0, 0                                    
 2007ca4:	22 80 00 17 	be,a   2007d00 <pthread_once+0x70>             
 2007ca8:	b0 10 20 16 	mov  0x16, %i0                                 
    return EINVAL;                                                    
                                                                      
  if ( !once_control->init_executed ) {                               
 2007cac:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 2007cb0:	80 a0 60 00 	cmp  %g1, 0                                    
 2007cb4:	12 80 00 13 	bne  2007d00 <pthread_once+0x70>               
 2007cb8:	b0 10 20 00 	clr  %i0                                       
    rtems_mode saveMode;                                              
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
 2007cbc:	90 10 21 00 	mov  0x100, %o0                                
 2007cc0:	92 10 21 00 	mov  0x100, %o1                                
 2007cc4:	40 00 03 0d 	call  20088f8 <rtems_task_mode>                
 2007cc8:	94 07 bf fc 	add  %fp, -4, %o2                              
    if ( !once_control->init_executed ) {                             
 2007ccc:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 2007cd0:	80 a0 60 00 	cmp  %g1, 0                                    
 2007cd4:	12 80 00 07 	bne  2007cf0 <pthread_once+0x60>               <== NEVER TAKEN
 2007cd8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      once_control->is_initialized = true;                            
 2007cdc:	82 10 20 01 	mov  1, %g1                                    
 2007ce0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
      once_control->init_executed = true;                             
      (*init_routine)();                                              
 2007ce4:	9f c6 40 00 	call  %i1                                      
 2007ce8:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
 2007cec:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 2007cf0:	92 10 21 00 	mov  0x100, %o1                                
 2007cf4:	94 07 bf fc 	add  %fp, -4, %o2                              
 2007cf8:	40 00 03 00 	call  20088f8 <rtems_task_mode>                
 2007cfc:	b0 10 20 00 	clr  %i0                                       
 2007d00:	81 c7 e0 08 	ret                                            
 2007d04:	81 e8 00 00 	restore                                        
  pthread_once_t  *once_control,                                      
  void           (*init_routine)(void)                                
)                                                                     
{                                                                     
  if ( !once_control || !init_routine )                               
    return EINVAL;                                                    
 2007d08:	b0 10 20 16 	mov  0x16, %i0                                 
      (*init_routine)();                                              
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
  }                                                                   
  return 0;                                                           
}                                                                     
 2007d0c:	81 c7 e0 08 	ret                                            
 2007d10:	81 e8 00 00 	restore                                        
                                                                      

02007db0 <pthread_rwlock_init>: int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) {
 2007db0:	9d e3 bf 90 	save  %sp, -112, %sp                           
  const pthread_rwlockattr_t  *the_attr;                              
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !rwlock )                                                      
 2007db4:	80 a6 20 00 	cmp  %i0, 0                                    
 2007db8:	12 80 00 04 	bne  2007dc8 <pthread_rwlock_init+0x18>        
 2007dbc:	80 a6 60 00 	cmp  %i1, 0                                    
  switch ( the_attr->process_shared ) {                               
    case PTHREAD_PROCESS_PRIVATE:    /* only supported values */      
      break;                                                          
    case PTHREAD_PROCESS_SHARED:                                      
    default:                                                          
      return EINVAL;                                                  
 2007dc0:	81 c7 e0 08 	ret                                            
 2007dc4:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
 2007dc8:	32 80 00 06 	bne,a   2007de0 <pthread_rwlock_init+0x30>     
 2007dcc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
    the_attr = attr;                                                  
  } else {                                                            
    (void) pthread_rwlockattr_init( &default_attr );                  
 2007dd0:	90 07 bf f8 	add  %fp, -8, %o0                              
 2007dd4:	40 00 01 b0 	call  2008494 <pthread_rwlockattr_init>        
 2007dd8:	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 )                                    
 2007ddc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2007de0:	80 a0 60 00 	cmp  %g1, 0                                    
 2007de4:	22 80 00 13 	be,a   2007e30 <pthread_rwlock_init+0x80>      <== NEVER TAKEN
 2007de8:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
 2007dec:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 2007df0:	80 a0 60 00 	cmp  %g1, 0                                    
 2007df4:	32 80 00 0f 	bne,a   2007e30 <pthread_rwlock_init+0x80>     <== NEVER TAKEN
 2007df8:	b0 10 20 16 	mov  0x16, %i0                                 <== 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;                  
 2007dfc:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
 2007e00:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2	! 2022090 <_Thread_Dispatch_disable_level>
 */                                                                   
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(         
  CORE_RWLock_Attributes *the_attributes                              
)                                                                     
{                                                                     
  the_attributes->XXX = 0;                                            
 2007e04:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
                                                                      
    ++level;                                                          
 2007e08:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2007e0c:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
 *  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 *)                                     
 2007e10:	39 00 80 88 	sethi  %hi(0x2022000), %i4                     
 2007e14:	40 00 0a 7e 	call  200a80c <_Objects_Allocate>              
 2007e18:	90 17 22 a4 	or  %i4, 0x2a4, %o0	! 20222a4 <_POSIX_RWLock_Information>
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_rwlock = _POSIX_RWLock_Allocate();                              
                                                                      
  if ( !the_rwlock ) {                                                
 2007e1c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2007e20:	12 80 00 06 	bne  2007e38 <pthread_rwlock_init+0x88>        
 2007e24:	90 07 60 10 	add  %i5, 0x10, %o0                            
    _Thread_Enable_dispatch();                                        
 2007e28:	40 00 0f b0 	call  200bce8 <_Thread_Enable_dispatch>        
 2007e2c:	b0 10 20 0b 	mov  0xb, %i0                                  
 2007e30:	81 c7 e0 08 	ret                                            
 2007e34:	81 e8 00 00 	restore                                        
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );    
 2007e38:	40 00 08 dd 	call  200a1ac <_CORE_RWLock_Initialize>        
 2007e3c:	92 07 bf f4 	add  %fp, -12, %o1                             
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 2007e40:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 2007e44:	b8 17 22 a4 	or  %i4, 0x2a4, %i4                            
 2007e48:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 2007e4c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 2007e50:	85 28 a0 02 	sll  %g2, 2, %g2                               
 2007e54:	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;                                   
 2007e58:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    &_POSIX_RWLock_Information,                                       
    &the_rwlock->Object,                                              
    0                                                                 
  );                                                                  
                                                                      
  *rwlock = the_rwlock->Object.id;                                    
 2007e5c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
 2007e60:	40 00 0f a2 	call  200bce8 <_Thread_Enable_dispatch>        
 2007e64:	b0 10 20 00 	clr  %i0                                       
 2007e68:	81 c7 e0 08 	ret                                            
 2007e6c:	81 e8 00 00 	restore                                        
                                                                      

02008764 <pthread_rwlock_timedrdlock>: int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
 2008764:	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 )                                                      
 2008768:	80 a6 20 00 	cmp  %i0, 0                                    
 200876c:	12 80 00 04 	bne  200877c <pthread_rwlock_timedrdlock+0x18> 
 2008770:	92 07 bf fc 	add  %fp, -4, %o1                              
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
 2008774:	81 c7 e0 08 	ret                                            
 2008778:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
   *                                                                  
   *  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 );       
 200877c:	40 00 19 cc 	call  200eeac <_POSIX_Absolute_timeout_to_ticks>
 2008780:	90 10 00 19 	mov  %i1, %o0                                  
 2008784:	d2 06 00 00 	ld  [ %i0 ], %o1                               
 2008788:	ba 10 00 08 	mov  %o0, %i5                                  
 200878c:	94 07 bf f8 	add  %fp, -8, %o2                              
 2008790:	11 00 80 82 	sethi  %hi(0x2020800), %o0                     
 2008794:	40 00 0b 30 	call  200b454 <_Objects_Get>                   
 2008798:	90 12 20 b4 	or  %o0, 0xb4, %o0	! 20208b4 <_POSIX_RWLock_Information>
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
 200879c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 20087a0:	80 a0 60 00 	cmp  %g1, 0                                    
 20087a4:	32 80 00 21 	bne,a   2008828 <pthread_rwlock_timedrdlock+0xc4>
 20087a8:	b0 10 20 16 	mov  0x16, %i0                                 
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_reading(                                
 20087ac:	d2 06 00 00 	ld  [ %i0 ], %o1                               
 20087b0:	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 )                
 20087b4:	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(                                
 20087b8:	90 02 20 10 	add  %o0, 0x10, %o0                            
 20087bc:	80 a0 00 01 	cmp  %g0, %g1                                  
 20087c0:	98 10 20 00 	clr  %o4                                       
 20087c4:	b8 60 3f ff 	subx  %g0, -1, %i4                             
 20087c8:	40 00 07 9e 	call  200a640 <_CORE_RWLock_Obtain_for_reading>
 20087cc:	94 10 00 1c 	mov  %i4, %o2                                  
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
 20087d0:	40 00 0e d9 	call  200c334 <_Thread_Enable_dispatch>        
 20087d4:	01 00 00 00 	nop                                            
      if ( !do_wait ) {                                               
 20087d8:	80 a7 20 00 	cmp  %i4, 0                                    
 20087dc:	12 80 00 0e 	bne  2008814 <pthread_rwlock_timedrdlock+0xb0> 
 20087e0:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
        if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
 20087e4:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1	! 2020c10 <_Per_CPU_Information+0x10>
 20087e8:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
 20087ec:	80 a0 60 02 	cmp  %g1, 2                                    
 20087f0:	32 80 00 0a 	bne,a   2008818 <pthread_rwlock_timedrdlock+0xb4>
 20087f4:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
	  if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                    
 20087f8:	80 a7 60 00 	cmp  %i5, 0                                    
 20087fc:	22 80 00 0b 	be,a   2008828 <pthread_rwlock_timedrdlock+0xc4><== NEVER TAKEN
 2008800:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
	    return EINVAL;                                                   
	  if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                
 2008804:	ba 07 7f ff 	add  %i5, -1, %i5                              
 2008808:	80 a7 60 01 	cmp  %i5, 1                                    
 200880c:	08 80 00 07 	bleu  2008828 <pthread_rwlock_timedrdlock+0xc4><== ALWAYS TAKEN
 2008810:	b0 10 20 74 	mov  0x74, %i0                                 
	    return ETIMEDOUT;                                                
        }                                                             
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
        (CORE_RWLock_Status) _Thread_Executing->Wait.return_code      
 2008814:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
 2008818:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1	! 2020c10 <_Per_CPU_Information+0x10>
	       status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                     
	    return ETIMEDOUT;                                                
        }                                                             
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
 200881c:	40 00 00 38 	call  20088fc <_POSIX_RWLock_Translate_core_RWLock_return_code>
 2008820:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
 2008824:	b0 10 00 08 	mov  %o0, %i0                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
 2008828:	81 c7 e0 08 	ret                                            
 200882c:	81 e8 00 00 	restore                                        
                                                                      

02008830 <pthread_rwlock_timedwrlock>: int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
 2008830:	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 )                                                      
 2008834:	80 a6 20 00 	cmp  %i0, 0                                    
 2008838:	12 80 00 04 	bne  2008848 <pthread_rwlock_timedwrlock+0x18> 
 200883c:	92 07 bf fc 	add  %fp, -4, %o1                              
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
 2008840:	81 c7 e0 08 	ret                                            
 2008844:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
   *                                                                  
   *  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 );       
 2008848:	40 00 19 99 	call  200eeac <_POSIX_Absolute_timeout_to_ticks>
 200884c:	90 10 00 19 	mov  %i1, %o0                                  
 2008850:	d2 06 00 00 	ld  [ %i0 ], %o1                               
 2008854:	ba 10 00 08 	mov  %o0, %i5                                  
 2008858:	94 07 bf f8 	add  %fp, -8, %o2                              
 200885c:	11 00 80 82 	sethi  %hi(0x2020800), %o0                     
 2008860:	40 00 0a fd 	call  200b454 <_Objects_Get>                   
 2008864:	90 12 20 b4 	or  %o0, 0xb4, %o0	! 20208b4 <_POSIX_RWLock_Information>
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
 2008868:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 200886c:	80 a0 60 00 	cmp  %g1, 0                                    
 2008870:	32 80 00 21 	bne,a   20088f4 <pthread_rwlock_timedwrlock+0xc4>
 2008874:	b0 10 20 16 	mov  0x16, %i0                                 
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_writing(                                
 2008878:	d2 06 00 00 	ld  [ %i0 ], %o1                               
 200887c:	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 )                
 2008880:	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(                                
 2008884:	90 02 20 10 	add  %o0, 0x10, %o0                            
 2008888:	80 a0 00 01 	cmp  %g0, %g1                                  
 200888c:	98 10 20 00 	clr  %o4                                       
 2008890:	b8 60 3f ff 	subx  %g0, -1, %i4                             
 2008894:	40 00 07 9e 	call  200a70c <_CORE_RWLock_Obtain_for_writing>
 2008898:	94 10 00 1c 	mov  %i4, %o2                                  
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
 200889c:	40 00 0e a6 	call  200c334 <_Thread_Enable_dispatch>        
 20088a0:	01 00 00 00 	nop                                            
      if ( !do_wait &&                                                
 20088a4:	80 a7 20 00 	cmp  %i4, 0                                    
 20088a8:	12 80 00 0e 	bne  20088e0 <pthread_rwlock_timedwrlock+0xb0> 
 20088ac:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
 20088b0:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1	! 2020c10 <_Per_CPU_Information+0x10>
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait &&                                                
 20088b4:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
 20088b8:	80 a0 60 02 	cmp  %g1, 2                                    
 20088bc:	32 80 00 0a 	bne,a   20088e4 <pthread_rwlock_timedwrlock+0xb4>
 20088c0:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
	if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                      
 20088c4:	80 a7 60 00 	cmp  %i5, 0                                    
 20088c8:	22 80 00 0b 	be,a   20088f4 <pthread_rwlock_timedwrlock+0xc4><== NEVER TAKEN
 20088cc:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
	  return EINVAL;                                                     
	if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                  
 20088d0:	ba 07 7f ff 	add  %i5, -1, %i5                              
 20088d4:	80 a7 60 01 	cmp  %i5, 1                                    
 20088d8:	08 80 00 07 	bleu  20088f4 <pthread_rwlock_timedwrlock+0xc4><== ALWAYS TAKEN
 20088dc:	b0 10 20 74 	mov  0x74, %i0                                 
	     status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                       
	  return ETIMEDOUT;                                                  
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
        (CORE_RWLock_Status) _Thread_Executing->Wait.return_code      
 20088e0:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
 20088e4:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1	! 2020c10 <_Per_CPU_Information+0x10>
	if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                  
	     status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                       
	  return ETIMEDOUT;                                                  
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
 20088e8:	40 00 00 05 	call  20088fc <_POSIX_RWLock_Translate_core_RWLock_return_code>
 20088ec:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
 20088f0:	b0 10 00 08 	mov  %o0, %i0                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
 20088f4:	81 c7 e0 08 	ret                                            
 20088f8:	81 e8 00 00 	restore                                        
                                                                      

02009088 <pthread_rwlockattr_setpshared>: int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) {
 2009088:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr )                                                        
 200908c:	80 a0 60 00 	cmp  %g1, 0                                    
 2009090:	02 80 00 0a 	be  20090b8 <pthread_rwlockattr_setpshared+0x30>
 2009094:	90 10 20 16 	mov  0x16, %o0                                 
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
 2009098:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 200909c:	80 a0 a0 00 	cmp  %g2, 0                                    
 20090a0:	02 80 00 06 	be  20090b8 <pthread_rwlockattr_setpshared+0x30>
 20090a4:	80 a2 60 01 	cmp  %o1, 1                                    
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
 20090a8:	18 80 00 04 	bgu  20090b8 <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
 20090ac:	01 00 00 00 	nop                                            
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
 20090b0:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      return 0;                                                       
 20090b4:	90 10 20 00 	clr  %o0                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
 20090b8:	81 c3 e0 08 	retl                                           
                                                                      

0200a0b0 <pthread_setschedparam>: int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) {
 200a0b0:	9d e3 bf 90 	save  %sp, -112, %sp                           
  int                                  rc;                            
                                                                      
  /*                                                                  
   *  Check all the parameters                                        
   */                                                                 
  if ( !param )                                                       
 200a0b4:	80 a6 a0 00 	cmp  %i2, 0                                    
 200a0b8:	02 80 00 40 	be  200a1b8 <pthread_setschedparam+0x108>      
 200a0bc:	b6 10 20 16 	mov  0x16, %i3                                 
    return EINVAL;                                                    
                                                                      
  rc = _POSIX_Thread_Translate_sched_param(                           
 200a0c0:	90 10 00 19 	mov  %i1, %o0                                  
 200a0c4:	92 10 00 1a 	mov  %i2, %o1                                  
 200a0c8:	94 07 bf f4 	add  %fp, -12, %o2                             
 200a0cc:	40 00 17 8e 	call  200ff04 <_POSIX_Thread_Translate_sched_param>
 200a0d0:	96 07 bf f8 	add  %fp, -8, %o3                              
    policy,                                                           
    param,                                                            
    &budget_algorithm,                                                
    &budget_callout                                                   
  );                                                                  
  if ( rc )                                                           
 200a0d4:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 200a0d8:	32 80 00 39 	bne,a   200a1bc <pthread_setschedparam+0x10c>  
 200a0dc:	b0 10 00 1b 	mov  %i3, %i0                                  
    return rc;                                                        
                                                                      
  /*                                                                  
   *  Actually change the scheduling policy and parameters            
   */                                                                 
  the_thread = _Thread_Get( thread, &location );                      
 200a0e0:	90 10 00 18 	mov  %i0, %o0                                  
 200a0e4:	40 00 0c 3b 	call  200d1d0 <_Thread_Get>                    
 200a0e8:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 200a0ec:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200a0f0:	80 a0 60 00 	cmp  %g1, 0                                    
 200a0f4:	12 80 00 30 	bne  200a1b4 <pthread_setschedparam+0x104>     
 200a0f8:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
 200a0fc:	fa 02 21 5c 	ld  [ %o0 + 0x15c ], %i5                       
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
 200a100:	c2 07 60 84 	ld  [ %i5 + 0x84 ], %g1                        
 200a104:	80 a0 60 04 	cmp  %g1, 4                                    
 200a108:	32 80 00 05 	bne,a   200a11c <pthread_setschedparam+0x6c>   
 200a10c:	f2 27 60 84 	st  %i1, [ %i5 + 0x84 ]                        
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
 200a110:	40 00 10 28 	call  200e1b0 <_Watchdog_Remove>               
 200a114:	90 07 60 a8 	add  %i5, 0xa8, %o0                            
                                                                      
      api->schedpolicy = policy;                                      
 200a118:	f2 27 60 84 	st  %i1, [ %i5 + 0x84 ]                        
      api->schedparam  = *param;                                      
 200a11c:	90 07 60 88 	add  %i5, 0x88, %o0                            
 200a120:	92 10 00 1a 	mov  %i2, %o1                                  
 200a124:	40 00 23 d0 	call  2013064 <memcpy>                         
 200a128:	94 10 20 1c 	mov  0x1c, %o2                                 
      the_thread->budget_algorithm = budget_algorithm;                
 200a12c:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
      the_thread->budget_callout   = budget_callout;                  
                                                                      
      switch ( api->schedpolicy ) {                                   
 200a130:	80 a6 60 00 	cmp  %i1, 0                                    
      if ( api->schedpolicy == SCHED_SPORADIC )                       
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
      the_thread->budget_algorithm = budget_algorithm;                
 200a134:	c2 27 20 78 	st  %g1, [ %i4 + 0x78 ]                        
      the_thread->budget_callout   = budget_callout;                  
 200a138:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
      switch ( api->schedpolicy ) {                                   
 200a13c:	06 80 00 1b 	bl  200a1a8 <pthread_setschedparam+0xf8>       <== NEVER TAKEN
 200a140:	c2 27 20 7c 	st  %g1, [ %i4 + 0x7c ]                        
 200a144:	80 a6 60 02 	cmp  %i1, 2                                    
 200a148:	04 80 00 07 	ble  200a164 <pthread_setschedparam+0xb4>      
 200a14c:	03 00 80 8a 	sethi  %hi(0x2022800), %g1                     
 200a150:	80 a6 60 04 	cmp  %i1, 4                                    
 200a154:	12 80 00 15 	bne  200a1a8 <pthread_setschedparam+0xf8>      <== NEVER TAKEN
 200a158:	01 00 00 00 	nop                                            
             true                                                     
          );                                                          
          break;                                                      
                                                                      
        case SCHED_SPORADIC:                                          
          api->ss_high_priority = api->schedparam.sched_priority;     
 200a15c:	10 80 00 0d 	b  200a190 <pthread_setschedparam+0xe0>        
 200a160:	c2 07 60 88 	ld  [ %i5 + 0x88 ], %g1                        
                                                                      
      switch ( api->schedpolicy ) {                                   
        case SCHED_OTHER:                                             
        case SCHED_FIFO:                                              
        case SCHED_RR:                                                
          the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;  
 200a164:	c2 00 63 10 	ld  [ %g1 + 0x310 ], %g1                       
                                                                      
          the_thread->real_priority =                                 
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
 200a168:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
      switch ( api->schedpolicy ) {                                   
        case SCHED_OTHER:                                             
        case SCHED_FIFO:                                              
        case SCHED_RR:                                                
          the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;  
 200a16c:	c2 27 20 74 	st  %g1, [ %i4 + 0x74 ]                        
 200a170:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
 200a174:	d2 08 62 ac 	ldub  [ %g1 + 0x2ac ], %o1	! 2021eac <rtems_maximum_priority>
 200a178:	c2 07 60 88 	ld  [ %i5 + 0x88 ], %g1                        
                                                                      
          the_thread->real_priority =                                 
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
 200a17c:	94 10 20 01 	mov  1, %o2                                    
 200a180:	92 22 40 01 	sub  %o1, %g1, %o1                             
 200a184:	40 00 0a d5 	call  200ccd8 <_Thread_Change_priority>        
 200a188:	d2 27 20 18 	st  %o1, [ %i4 + 0x18 ]                        
             the_thread,                                              
             the_thread->real_priority,                               
             true                                                     
          );                                                          
          break;                                                      
 200a18c:	30 80 00 07 	b,a   200a1a8 <pthread_setschedparam+0xf8>     
                                                                      
        case SCHED_SPORADIC:                                          
          api->ss_high_priority = api->schedparam.sched_priority;     
          _Watchdog_Remove( &api->Sporadic_timer );                   
 200a190:	90 07 60 a8 	add  %i5, 0xa8, %o0                            
 200a194:	40 00 10 07 	call  200e1b0 <_Watchdog_Remove>               
 200a198:	c2 27 60 a4 	st  %g1, [ %i5 + 0xa4 ]                        
          _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );        
 200a19c:	90 10 20 00 	clr  %o0                                       
 200a1a0:	7f ff ff 7e 	call  2009f98 <_POSIX_Threads_Sporadic_budget_TSR>
 200a1a4:	92 10 00 1c 	mov  %i4, %o1                                  
          break;                                                      
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
 200a1a8:	40 00 0b fe 	call  200d1a0 <_Thread_Enable_dispatch>        
 200a1ac:	b0 10 00 1b 	mov  %i3, %i0                                  
 200a1b0:	30 80 00 03 	b,a   200a1bc <pthread_setschedparam+0x10c>    
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
 200a1b4:	b6 10 20 03 	mov  3, %i3                                    
}                                                                     
 200a1b8:	b0 10 00 1b 	mov  %i3, %i0                                  
 200a1bc:	81 c7 e0 08 	ret                                            
 200a1c0:	81 e8 00 00 	restore                                        
                                                                      

020079d4 <pthread_testcancel>: /* * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) {
 20079d4:	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() )                                        
 20079d8:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
 20079dc:	82 10 61 40 	or  %g1, 0x140, %g1	! 201e940 <_Per_CPU_Information>
 20079e0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 20079e4:	80 a0 a0 00 	cmp  %g2, 0                                    
 20079e8:	12 80 00 16 	bne  2007a40 <pthread_testcancel+0x6c>         <== NEVER TAKEN
 20079ec:	05 00 80 79 	sethi  %hi(0x201e400), %g2                     
    return;                                                           
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
 20079f0:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %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;                  
 20079f4:	c6 00 a0 20 	ld  [ %g2 + 0x20 ], %g3                        
 20079f8:	c2 00 61 5c 	ld  [ %g1 + 0x15c ], %g1                       
                                                                      
    ++level;                                                          
 20079fc:	86 00 e0 01 	inc  %g3                                       
    _Thread_Dispatch_disable_level = level;                           
 2007a00:	c6 20 a0 20 	st  %g3, [ %g2 + 0x20 ]                        
                                                                      
  _Thread_Disable_dispatch();                                         
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
 2007a04:	c4 00 60 d8 	ld  [ %g1 + 0xd8 ], %g2                        
 2007a08:	80 a0 a0 00 	cmp  %g2, 0                                    
 2007a0c:	12 80 00 05 	bne  2007a20 <pthread_testcancel+0x4c>         <== NEVER TAKEN
 2007a10:	ba 10 20 00 	clr  %i5                                       
 2007a14:	c2 00 60 e0 	ld  [ %g1 + 0xe0 ], %g1                        
 2007a18:	80 a0 00 01 	cmp  %g0, %g1                                  
 2007a1c:	ba 40 20 00 	addx  %g0, 0, %i5                              
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
  _Thread_Enable_dispatch();                                          
 2007a20:	40 00 0b c1 	call  200a924 <_Thread_Enable_dispatch>        
 2007a24:	01 00 00 00 	nop                                            
                                                                      
  if ( cancel )                                                       
 2007a28:	80 8f 60 ff 	btst  0xff, %i5                                
 2007a2c:	02 80 00 05 	be  2007a40 <pthread_testcancel+0x6c>          
 2007a30:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
    _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );        
 2007a34:	f0 00 61 50 	ld  [ %g1 + 0x150 ], %i0	! 201e950 <_Per_CPU_Information+0x10>
 2007a38:	40 00 17 43 	call  200d744 <_POSIX_Thread_Exit>             
 2007a3c:	93 e8 3f ff 	restore  %g0, -1, %o1                          
 2007a40:	81 c7 e0 08 	ret                                            
 2007a44:	81 e8 00 00 	restore                                        
                                                                      

0200c82c <ramdisk_allocate>: void *area_begin, uint32_t media_block_size, rtems_blkdev_bnum media_block_count, bool trace ) {
 200c82c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  struct ramdisk *rd = malloc(sizeof(struct ramdisk));                
 200c830:	7f ff e1 3c 	call  2004d20 <malloc>                         
 200c834:	90 10 20 10 	mov  0x10, %o0                                 
                                                                      
  if (rd == NULL) {                                                   
 200c838:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200c83c:	02 80 00 16 	be  200c894 <ramdisk_allocate+0x68>            <== NEVER TAKEN
 200c840:	80 a6 20 00 	cmp  %i0, 0                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
 200c844:	32 80 00 0e 	bne,a   200c87c <ramdisk_allocate+0x50>        
 200c848:	c0 2f 60 0d 	clrb  [ %i5 + 0xd ]                            
    area_begin = calloc(media_block_count, media_block_size);         
 200c84c:	90 10 00 1a 	mov  %i2, %o0                                  
 200c850:	7f ff df 1f 	call  20044cc <calloc>                         
 200c854:	92 10 00 19 	mov  %i1, %o1                                  
    if (area_begin == NULL) {                                         
 200c858:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200c85c:	12 80 00 07 	bne  200c878 <ramdisk_allocate+0x4c>           <== ALWAYS TAKEN
 200c860:	82 10 20 01 	mov  1, %g1                                    
      free(rd);                                                       
 200c864:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 200c868:	7f ff df ed 	call  200481c <free>                           <== NOT EXECUTED
 200c86c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      
      return NULL;                                                    
 200c870:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200c874:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
 200c878:	c2 2f 60 0d 	stb  %g1, [ %i5 + 0xd ]                        
  }                                                                   
  rd->block_size = media_block_size;                                  
  rd->block_num = media_block_count;                                  
  rd->area = area_begin;                                              
  rd->trace = trace;                                                  
  rd->initialized = true;                                             
 200c87c:	82 10 20 01 	mov  1, %g1                                    
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
  }                                                                   
  rd->block_size = media_block_size;                                  
 200c880:	f2 27 40 00 	st  %i1, [ %i5 ]                               
  rd->block_num = media_block_count;                                  
 200c884:	f4 27 60 04 	st  %i2, [ %i5 + 4 ]                           
  rd->area = area_begin;                                              
 200c888:	f0 27 60 08 	st  %i0, [ %i5 + 8 ]                           
  rd->trace = trace;                                                  
 200c88c:	f6 2f 60 0e 	stb  %i3, [ %i5 + 0xe ]                        
  rd->initialized = true;                                             
 200c890:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
                                                                      
  return rd;                                                          
}                                                                     
 200c894:	b0 10 00 1d 	mov  %i5, %i0                                  
 200c898:	81 c7 e0 08 	ret                                            
 200c89c:	81 e8 00 00 	restore                                        
                                                                      

0200c8a0 <ramdisk_free>: void ramdisk_free(ramdisk *rd) {
 200c8a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rd != NULL) {                                                   
 200c8a4:	80 a6 20 00 	cmp  %i0, 0                                    
 200c8a8:	02 80 00 0a 	be  200c8d0 <ramdisk_free+0x30>                <== NEVER TAKEN
 200c8ac:	01 00 00 00 	nop                                            
    if (rd->malloced) {                                               
 200c8b0:	c2 0e 20 0d 	ldub  [ %i0 + 0xd ], %g1                       
 200c8b4:	80 a0 60 00 	cmp  %g1, 0                                    
 200c8b8:	02 80 00 04 	be  200c8c8 <ramdisk_free+0x28>                
 200c8bc:	01 00 00 00 	nop                                            
      free(rd->area);                                                 
 200c8c0:	7f ff df d7 	call  200481c <free>                           
 200c8c4:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
    }                                                                 
    free(rd);                                                         
 200c8c8:	7f ff df d5 	call  200481c <free>                           
 200c8cc:	81 e8 00 00 	restore                                        
 200c8d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200c8d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200daac <ramdisk_initialize>: rtems_device_driver ramdisk_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *arg __attribute__((unused))) {
 200daac:	9d e3 bf 88 	save  %sp, -120, %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();                                  
 200dab0:	7f ff da ff 	call  20046ac <rtems_disk_io_initialize>       
 200dab4:	a8 10 00 18 	mov  %i0, %l4                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
 200dab8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200dabc:	12 80 00 46 	bne  200dbd4 <ramdisk_initialize+0x128>        <== NEVER TAKEN
 200dac0:	3b 00 80 98 	sethi  %hi(0x2026000), %i5                     
     * 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));
 200dac4:	d0 07 60 5c 	ld  [ %i5 + 0x5c ], %o0	! 202605c <rtems_ramdisk_configuration_size>
 200dac8:	92 10 20 10 	mov  0x10, %o1                                 
 200dacc:	7f ff de 9b 	call  2005538 <calloc>                         
 200dad0:	33 00 80 98 	sethi  %hi(0x2026000), %i1                     
    r->trace = false;                                                 
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
 200dad4:	a6 10 00 1d 	mov  %i5, %l3                                  
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
 200dad8:	39 0b d9 19 	sethi  %hi(0x2f646400), %i4                    
 200dadc:	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, 
 200dae0:	2b 00 80 36 	sethi  %hi(0x200d800), %l5                     
     * 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));
 200dae4:	b6 10 00 08 	mov  %o0, %i3                                  
    r->trace = false;                                                 
 200dae8:	c0 2a 20 0e 	clrb  [ %o0 + 0xe ]                            
    rtems_device_major_number major,                                  
    rtems_device_minor_number minor __attribute__((unused)),          
    void *arg __attribute__((unused)))                                
{                                                                     
    rtems_device_minor_number i;                                      
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;            
 200daec:	b2 16 60 60 	or  %i1, 0x60, %i1                             
     * 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++)  
 200daf0:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
 200daf4:	b8 17 21 76 	or  %i4, 0x176, %i4                            
 200daf8:	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);          
 200dafc:	b0 07 bf f0 	add  %fp, -16, %i0                             
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
            r->area = c->location;                                    
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
 200db00:	aa 15 63 dc 	or  %l5, 0x3dc, %l5                            
     * 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++)  
 200db04:	10 80 00 2f 	b  200dbc0 <ramdisk_initialize+0x114>          
 200db08:	a0 10 20 01 	mov  1, %l0                                    
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
 200db0c:	f4 2f bf f8 	stb  %i2, [ %fp + -8 ]                         
        r->block_size = c->block_size;                                
 200db10:	e4 06 40 00 	ld  [ %i1 ], %l2                               
        r->block_num = c->block_num;                                  
 200db14:	e2 06 60 04 	ld  [ %i1 + 4 ], %l1                           
        if (c->location == NULL)                                      
 200db18:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    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;                                
 200db1c:	e4 26 c0 00 	st  %l2, [ %i3 ]                               
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
 200db20:	80 a0 60 00 	cmp  %g1, 0                                    
 200db24:	12 80 00 0f 	bne  200db60 <ramdisk_initialize+0xb4>         <== NEVER TAKEN
 200db28:	e2 26 e0 04 	st  %l1, [ %i3 + 4 ]                           
        {                                                             
            r->malloced = true;                                       
            r->area = malloc(r->block_size * r->block_num);           
 200db2c:	92 10 00 12 	mov  %l2, %o1                                  
        name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;                 
        r->block_size = c->block_size;                                
        r->block_num = c->block_num;                                  
        if (c->location == NULL)                                      
        {                                                             
            r->malloced = true;                                       
 200db30:	e0 2e e0 0d 	stb  %l0, [ %i3 + 0xd ]                        
            r->area = malloc(r->block_size * r->block_num);           
 200db34:	40 00 4f 4d 	call  2021868 <.umul>                          
 200db38:	90 10 00 11 	mov  %l1, %o0                                  
 200db3c:	7f ff e0 e4 	call  2005ecc <malloc>                         
 200db40:	01 00 00 00 	nop                                            
            if (r->area == NULL) /* No enough memory for this disk */ 
 200db44:	80 a2 20 00 	cmp  %o0, 0                                    
 200db48:	12 80 00 04 	bne  200db58 <ramdisk_initialize+0xac>         <== ALWAYS TAKEN
 200db4c:	d0 26 e0 08 	st  %o0, [ %i3 + 8 ]                           
        {                                                             
            if (r->malloced)                                          
            {                                                         
                free(r->area);                                        
            }                                                         
            r->initialized = false;                                   
 200db50:	10 80 00 19 	b  200dbb4 <ramdisk_initialize+0x108>          <== NOT EXECUTED
 200db54:	c0 2e e0 0c 	clrb  [ %i3 + 0xc ]                            <== NOT EXECUTED
                r->initialized = false;                               
                continue;                                             
            }                                                         
            else                                                      
            {                                                         
                r->initialized = true;                                
 200db58:	10 80 00 05 	b  200db6c <ramdisk_initialize+0xc0>           
 200db5c:	e0 2e e0 0c 	stb  %l0, [ %i3 + 0xc ]                        
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
 200db60:	c0 2e e0 0d 	clrb  [ %i3 + 0xd ]                            <== NOT EXECUTED
            r->initialized = true;                                    
 200db64:	e0 2e e0 0c 	stb  %l0, [ %i3 + 0xc ]                        <== NOT EXECUTED
            r->area = c->location;                                    
 200db68:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           <== NOT EXECUTED
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
 200db6c:	f0 23 a0 5c 	st  %i0, [ %sp + 0x5c ]                        
 200db70:	90 10 00 14 	mov  %l4, %o0                                  
 200db74:	92 10 00 1a 	mov  %i2, %o1                                  
 200db78:	94 10 00 12 	mov  %l2, %o2                                  
 200db7c:	96 10 00 11 	mov  %l1, %o3                                  
 200db80:	98 10 00 15 	mov  %l5, %o4                                  
 200db84:	7f ff da 34 	call  2004454 <rtems_disk_create_phys>         
 200db88:	9a 10 00 1b 	mov  %i3, %o5                                  
                                    ramdisk_ioctl, r, name);          
        if (rc != RTEMS_SUCCESSFUL)                                   
 200db8c:	80 a2 20 00 	cmp  %o0, 0                                    
 200db90:	22 80 00 0a 	be,a   200dbb8 <ramdisk_initialize+0x10c>      <== ALWAYS TAKEN
 200db94:	b4 06 a0 01 	inc  %i2                                       
        {                                                             
            if (r->malloced)                                          
 200db98:	c2 0e e0 0d 	ldub  [ %i3 + 0xd ], %g1                       <== NOT EXECUTED
 200db9c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 200dba0:	22 80 00 05 	be,a   200dbb4 <ramdisk_initialize+0x108>      <== NOT EXECUTED
 200dba4:	c0 2e e0 0c 	clrb  [ %i3 + 0xc ]                            <== NOT EXECUTED
            {                                                         
                free(r->area);                                        
 200dba8:	7f ff df 38 	call  2005888 <free>                           <== NOT EXECUTED
 200dbac:	d0 06 e0 08 	ld  [ %i3 + 8 ], %o0                           <== NOT EXECUTED
            }                                                         
            r->initialized = false;                                   
 200dbb0:	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++)  
 200dbb4:	b4 06 a0 01 	inc  %i2                                       <== NOT EXECUTED
 200dbb8:	b2 06 60 0c 	add  %i1, 0xc, %i1                             
 200dbbc:	b6 06 e0 10 	add  %i3, 0x10, %i3                            
 200dbc0:	c2 04 e0 5c 	ld  [ %l3 + 0x5c ], %g1                        
 200dbc4:	80 a6 80 01 	cmp  %i2, %g1                                  
 200dbc8:	2a bf ff d1 	bcs,a   200db0c <ramdisk_initialize+0x60>      
 200dbcc:	f8 3f bf f0 	std  %i4, [ %fp + -16 ]                        
                free(r->area);                                        
            }                                                         
            r->initialized = false;                                   
        }                                                             
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
 200dbd0:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 200dbd4:	81 c7 e0 08 	ret                                            
 200dbd8:	81 e8 00 00 	restore                                        
                                                                      

0200c700 <ramdisk_ioctl>: return 0; } int ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) {
 200c700:	9d e3 bf a0 	save  %sp, -96, %sp                            
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);              
                                                                      
    switch (req)                                                      
 200c704:	05 08 00 10 	sethi  %hi(0x20004000), %g2                    
    return 0;                                                         
}                                                                     
                                                                      
int                                                                   
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)        
{                                                                     
 200c708:	ba 10 00 1a 	mov  %i2, %i5                                  
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);              
                                                                      
    switch (req)                                                      
 200c70c:	84 10 a2 07 	or  %g2, 0x207, %g2                            
 200c710:	80 a6 40 02 	cmp  %i1, %g2                                  
 200c714:	02 80 00 37 	be  200c7f0 <ramdisk_ioctl+0xf0>               
 200c718:	f8 06 20 3c 	ld  [ %i0 + 0x3c ], %i4                        
 200c71c:	05 30 06 10 	sethi  %hi(0xc0184000), %g2                    
 200c720:	84 10 a2 01 	or  %g2, 0x201, %g2	! c0184201 <RAM_END+0xbdd84201>
 200c724:	80 a6 40 02 	cmp  %i1, %g2                                  
 200c728:	12 80 00 39 	bne  200c80c <ramdisk_ioctl+0x10c>             
 200c72c:	01 00 00 00 	nop                                            
    {                                                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
                                                                      
            switch (r->req)                                           
 200c730:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 200c734:	80 a0 60 00 	cmp  %g1, 0                                    
 200c738:	02 80 00 07 	be  200c754 <ramdisk_ioctl+0x54>               
 200c73c:	b6 06 a0 18 	add  %i2, 0x18, %i3                            
 200c740:	80 a0 60 01 	cmp  %g1, 1                                    
 200c744:	12 80 00 34 	bne  200c814 <ramdisk_ioctl+0x114>             <== NEVER TAKEN
 200c748:	01 00 00 00 	nop                                            
}                                                                     
                                                                      
static int                                                            
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)          
{                                                                     
    uint8_t *to = rd->area;                                           
 200c74c:	10 80 00 14 	b  200c79c <ramdisk_ioctl+0x9c>                
 200c750:	f2 07 20 08 	ld  [ %i4 + 8 ], %i1                           
#endif                                                                
                                                                      
static int                                                            
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)           
{                                                                     
    uint8_t *from = rd->area;                                         
 200c754:	f2 07 20 08 	ld  [ %i4 + 8 ], %i1                           
#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++)           
 200c758:	10 80 00 0b 	b  200c784 <ramdisk_ioctl+0x84>                
 200c75c:	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);
 200c760:	d2 07 00 00 	ld  [ %i4 ], %o1                               
 200c764:	40 00 3f ce 	call  201c69c <.umul>                          
 200c768:	f0 06 e0 08 	ld  [ %i3 + 8 ], %i0                           
 200c76c:	d4 06 e0 04 	ld  [ %i3 + 4 ], %o2                           
 200c770:	92 06 40 08 	add  %i1, %o0, %o1                             
#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++)           
 200c774:	b4 06 a0 01 	inc  %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);
 200c778:	90 10 00 18 	mov  %i0, %o0                                  
 200c77c:	40 00 1e ee 	call  2014334 <memcpy>                         
 200c780:	b6 06 e0 10 	add  %i3, 0x10, %i3                            
#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++)           
 200c784:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200c788:	80 a6 80 01 	cmp  %i2, %g1                                  
 200c78c:	2a bf ff f5 	bcs,a   200c760 <ramdisk_ioctl+0x60>           
 200c790:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
static inline void rtems_blkdev_request_done(                         
  rtems_blkdev_request *req,                                          
  rtems_status_code status                                            
)                                                                     
{                                                                     
  (*req->done)(req, status);                                          
 200c794:	10 80 00 11 	b  200c7d8 <ramdisk_ioctl+0xd8>                
 200c798:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
                                                                      
#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++)           
 200c79c:	10 80 00 0a 	b  200c7c4 <ramdisk_ioctl+0xc4>                
 200c7a0:	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);
 200c7a4:	d2 07 00 00 	ld  [ %i4 ], %o1                               
 200c7a8:	40 00 3f bd 	call  201c69c <.umul>                          
 200c7ac:	b4 06 a0 01 	inc  %i2                                       
 200c7b0:	d2 06 e0 08 	ld  [ %i3 + 8 ], %o1                           
 200c7b4:	d4 06 e0 04 	ld  [ %i3 + 4 ], %o2                           
 200c7b8:	90 06 40 08 	add  %i1, %o0, %o0                             
 200c7bc:	40 00 1e de 	call  2014334 <memcpy>                         
 200c7c0:	b6 06 e0 10 	add  %i3, 0x10, %i3                            
                                                                      
#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++)           
 200c7c4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 200c7c8:	80 a6 80 01 	cmp  %i2, %g1                                  
 200c7cc:	2a bf ff f6 	bcs,a   200c7a4 <ramdisk_ioctl+0xa4>           
 200c7d0:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
 200c7d4:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 200c7d8:	90 10 00 1d 	mov  %i5, %o0                                  
 200c7dc:	92 10 20 00 	clr  %o1                                       
 200c7e0:	9f c0 40 00 	call  %g1                                      
 200c7e4:	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);                      
 200c7e8:	81 c7 e0 08 	ret                                            
 200c7ec:	81 e8 00 00 	restore                                        
            }                                                         
            break;                                                    
        }                                                             
                                                                      
        case RTEMS_BLKIO_DELETED:                                     
            if (rd->free_at_delete_request) {                         
 200c7f0:	c2 0f 20 0f 	ldub  [ %i4 + 0xf ], %g1                       
 200c7f4:	80 a0 60 00 	cmp  %g1, 0                                    
 200c7f8:	02 80 00 07 	be  200c814 <ramdisk_ioctl+0x114>              
 200c7fc:	01 00 00 00 	nop                                            
              ramdisk_free(rd);                                       
 200c800:	40 00 00 28 	call  200c8a0 <ramdisk_free>                   
 200c804:	90 10 00 1c 	mov  %i4, %o0                                  
 200c808:	30 80 00 03 	b,a   200c814 <ramdisk_ioctl+0x114>            
            }                                                         
            break;                                                    
                                                                      
        default:                                                      
            return rtems_blkdev_ioctl (dd, req, argp);                
 200c80c:	40 00 0a 01 	call  200f010 <rtems_blkdev_ioctl>             
 200c810:	81 e8 00 00 	restore                                        
            break;                                                    
    }                                                                 
                                                                      
    errno = EINVAL;                                                   
 200c814:	40 00 1c 77 	call  20139f0 <__errno>                        
 200c818:	b0 10 3f ff 	mov  -1, %i0                                   
 200c81c:	82 10 20 16 	mov  0x16, %g1                                 
 200c820:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return -1;                                                        
}                                                                     
 200c824:	81 c7 e0 08 	ret                                            
 200c828:	81 e8 00 00 	restore                                        
                                                                      

0200c8d8 <ramdisk_register>: rtems_blkdev_bnum media_block_count, bool trace, const char *disk, dev_t *dev_ptr ) {
 200c8d8:	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);             
 200c8dc:	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;                                
 200c8e0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  ramdisk *rd = NULL;                                                 
  dev_t dev = 0;                                                      
                                                                      
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
 200c8e4:	13 00 80 7e 	sethi  %hi(0x201f800), %o1                     
 200c8e8:	94 07 bf fc 	add  %fp, -4, %o2                              
 200c8ec:	92 12 62 18 	or  %o1, 0x218, %o1                            
 200c8f0:	7f ff f2 86 	call  2009308 <rtems_io_register_driver>       
 200c8f4:	a0 10 20 0d 	mov  0xd, %l0                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 200c8f8:	80 a2 20 00 	cmp  %o0, 0                                    
 200c8fc:	32 80 00 20 	bne,a   200c97c <ramdisk_register+0xa4>        <== NEVER TAKEN
 200c900:	b0 10 00 10 	mov  %l0, %i0                                  <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);
 200c904:	96 10 00 1a 	mov  %i2, %o3                                  
 200c908:	92 10 00 18 	mov  %i0, %o1                                  
 200c90c:	7f ff ff c8 	call  200c82c <ramdisk_allocate>               
 200c910:	94 10 00 19 	mov  %i1, %o2                                  
  if (rd == NULL) {                                                   
 200c914:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 200c918:	12 80 00 04 	bne  200c928 <ramdisk_register+0x50>           <== ALWAYS TAKEN
 200c91c:	fa 07 bf fc 	ld  [ %fp + -4 ], %i5                          
    rtems_io_unregister_driver(major);                                
 200c920:	10 80 00 11 	b  200c964 <ramdisk_register+0x8c>             <== NOT EXECUTED
 200c924:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  dev = rtems_filesystem_make_dev_t(major, 0);                        
                                                                      
  sc = rtems_disk_create_phys(                                        
 200c928:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        
 200c92c:	90 10 00 1d 	mov  %i5, %o0                                  
 200c930:	92 10 20 00 	clr  %o1                                       
 200c934:	94 10 00 18 	mov  %i0, %o2                                  
 200c938:	96 10 00 19 	mov  %i1, %o3                                  
 200c93c:	19 00 80 31 	sethi  %hi(0x200c400), %o4                     
 200c940:	9a 10 00 1a 	mov  %i2, %o5                                  
 200c944:	7f ff dc 3b 	call  2003a30 <rtems_disk_create_phys>         
 200c948:	98 13 23 00 	or  %o4, 0x300, %o4                            
    media_block_count,                                                
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 200c94c:	80 a2 20 00 	cmp  %o0, 0                                    
 200c950:	22 80 00 08 	be,a   200c970 <ramdisk_register+0x98>         <== ALWAYS TAKEN
 200c954:	fa 27 00 00 	st  %i5, [ %i4 ]                               
    ramdisk_free(rd);                                                 
 200c958:	7f ff ff d2 	call  200c8a0 <ramdisk_free>                   <== NOT EXECUTED
 200c95c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    rtems_io_unregister_driver(major);                                
 200c960:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
 200c964:	7f ff f2 c8 	call  2009484 <rtems_io_unregister_driver>     <== NOT EXECUTED
 200c968:	b0 10 00 10 	mov  %l0, %i0                                  <== NOT EXECUTED
 200c96c:	30 80 00 04 	b,a   200c97c <ramdisk_register+0xa4>          <== NOT EXECUTED
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
 200c970:	c0 27 20 04 	clr  [ %i4 + 4 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200c974:	a0 10 20 00 	clr  %l0                                       
}                                                                     
 200c978:	b0 10 00 10 	mov  %l0, %i0                                  
 200c97c:	81 c7 e0 08 	ret                                            
 200c980:	81 e8 00 00 	restore                                        
                                                                      

02019dfc <read>: ssize_t read( int fd, void *buffer, size_t count ) {
 2019dfc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
 2019e00:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2019e04:	c2 00 61 f4 	ld  [ %g1 + 0x1f4 ], %g1	! 201c9f4 <rtems_libio_number_iops>
 2019e08:	80 a6 00 01 	cmp  %i0, %g1                                  
 2019e0c:	1a 80 00 16 	bcc  2019e64 <read+0x68>                       
 2019e10:	83 2e 20 03 	sll  %i0, 3, %g1                               
  iop = rtems_libio_iop( fd );                                        
 2019e14:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2019e18:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2019e1c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2019e20:	d0 00 60 44 	ld  [ %g1 + 0x44 ], %o0	! 201d444 <rtems_libio_iops>
 2019e24:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open( iop );                                   
 2019e28:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
 2019e2c:	80 88 61 00 	btst  0x100, %g1                               
 2019e30:	02 80 00 0d 	be  2019e64 <read+0x68>                        
 2019e34:	80 a6 60 00 	cmp  %i1, 0                                    
  rtems_libio_check_buffer( buffer );                                 
 2019e38:	12 80 00 06 	bne  2019e50 <read+0x54>                       <== ALWAYS TAKEN
 2019e3c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2019e40:	7f ff d6 0b 	call  200f66c <__errno>                        <== NOT EXECUTED
 2019e44:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2019e48:	10 80 00 0a 	b  2019e70 <read+0x74>                         <== NOT EXECUTED
 2019e4c:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
 2019e50:	02 80 00 10 	be  2019e90 <read+0x94>                        
 2019e54:	b0 10 20 00 	clr  %i0                                       
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
 2019e58:	80 88 60 02 	btst  2, %g1                                   
 2019e5c:	32 80 00 08 	bne,a   2019e7c <read+0x80>                    
 2019e60:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
 2019e64:	7f ff d6 02 	call  200f66c <__errno>                        
 2019e68:	01 00 00 00 	nop                                            
 2019e6c:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
 2019e70:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2019e74:	81 c7 e0 08 	ret                                            
 2019e78:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      
  /*                                                                  
   *  Now process the read().                                         
   */                                                                 
  return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );     
 2019e7c:	92 10 00 19 	mov  %i1, %o1                                  
 2019e80:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 2019e84:	9f c0 40 00 	call  %g1                                      
 2019e88:	94 10 00 1a 	mov  %i2, %o2                                  
 2019e8c:	b0 10 00 08 	mov  %o0, %i0                                  
}                                                                     
 2019e90:	81 c7 e0 08 	ret                                            
 2019e94:	81 e8 00 00 	restore                                        
                                                                      

020049d0 <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) {
 20049d0:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                  i;                                           
    rtems_sector_data_t *sector = NULL;                               
 20049d4:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    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))          
 20049d8:	80 a6 a0 00 	cmp  %i2, 0                                    
 20049dc:	02 80 00 61 	be  2004b60 <read_extended_partition+0x190>    <== NEVER TAKEN
 20049e0:	ba 10 20 19 	mov  0x19, %i5                                 
 20049e4:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
 20049e8:	80 a0 60 00 	cmp  %g1, 0                                    
 20049ec:	02 80 00 5d 	be  2004b60 <read_extended_partition+0x190>    <== NEVER TAKEN
 20049f0:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    /* get start sector of current extended partition */              
    here = ext_part->start;                                           
 20049f4:	f6 06 a0 04 	ld  [ %i2 + 4 ], %i3                           
    if (sector == NULL)                                               
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    off = sector_num * RTEMS_IDE_SECTOR_SIZE;                         
 20049f8:	bb 2e e0 09 	sll  %i3, 9, %i5                               
    new_off = lseek(fd, off, SEEK_SET);                               
 20049fc:	92 10 20 00 	clr  %o1                                       
 2004a00:	94 10 00 1d 	mov  %i5, %o2                                  
 2004a04:	40 00 04 be 	call  2005cfc <lseek>                          
 2004a08:	96 10 20 00 	clr  %o3                                       
    if (new_off != off) {                                             
 2004a0c:	80 a2 20 00 	cmp  %o0, 0                                    
 2004a10:	32 80 00 0e 	bne,a   2004a48 <read_extended_partition+0x78> <== NEVER TAKEN
 2004a14:	ba 10 20 1b 	mov  0x1b, %i5                                 <== NOT EXECUTED
 2004a18:	80 a2 40 1d 	cmp  %o1, %i5                                  
 2004a1c:	12 80 00 0b 	bne  2004a48 <read_extended_partition+0x78>    <== NEVER TAKEN
 2004a20:	ba 10 20 1b 	mov  0x1b, %i5                                 
 2004a24:	90 10 00 18 	mov  %i0, %o0                                  
 2004a28:	92 10 00 1b 	mov  %i3, %o1                                  
 2004a2c:	7f ff ff a2 	call  20048b4 <get_sector.part.0>              
 2004a30:	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)                                       
 2004a34:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2004a38:	02 80 00 09 	be  2004a5c <read_extended_partition+0x8c>     <== ALWAYS TAKEN
 2004a3c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    {                                                                 
        if (sector)                                                   
 2004a40:	10 80 00 04 	b  2004a50 <read_extended_partition+0x80>      <== NOT EXECUTED
 2004a44:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2004a48:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          <== NOT EXECUTED
 2004a4c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2004a50:	22 80 00 45 	be,a   2004b64 <read_extended_partition+0x194> <== NOT EXECUTED
 2004a54:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 2004a58:	30 80 00 40 	b,a   2004b58 <read_extended_partition+0x188>  <== 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) &&    
 2004a5c:	c6 0a 22 02 	ldub  [ %o0 + 0x202 ], %g3                     
 2004a60:	80 a0 e0 55 	cmp  %g3, 0x55                                 
 2004a64:	12 80 00 06 	bne  2004a7c <read_extended_partition+0xac>    <== NEVER TAKEN
 2004a68:	84 10 20 00 	clr  %g2                                       
 2004a6c:	c4 0a 22 03 	ldub  [ %o0 + 0x203 ], %g2                     
 2004a70:	84 18 a0 aa 	xor  %g2, 0xaa, %g2                            
 2004a74:	80 a0 00 02 	cmp  %g0, %g2                                  
 2004a78:	84 60 3f ff 	subx  %g0, -1, %g2                             
        if (sector)                                                   
            free(sector);                                             
        return rc;                                                    
    }                                                                 
                                                                      
    if (!msdos_signature_check(sector))                               
 2004a7c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2004a80:	12 80 00 06 	bne  2004a98 <read_extended_partition+0xc8>    <== ALWAYS TAKEN
 2004a84:	a0 02 21 d2 	add  %o0, 0x1d2, %l0                           
    {                                                                 
        free(sector);                                                 
 2004a88:	40 00 03 80 	call  2005888 <free>                           <== NOT EXECUTED
 2004a8c:	ba 10 20 19 	mov  0x19, %i5                                 <== NOT EXECUTED
    }                                                                 
                                                                      
    free(sector);                                                     
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
 2004a90:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004a94:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
 2004a98:	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)
 2004a9c:	a2 06 a0 10 	add  %i2, 0x10, %l1                            
 2004aa0:	90 04 3f f0 	add  %l0, -16, %o0                             
 2004aa4:	7f ff ff 9a 	call  200490c <data_to_part_desc.part.1>       
 2004aa8:	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)                                   
 2004aac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2004ab0:	02 80 00 04 	be  2004ac0 <read_extended_partition+0xf0>     <== ALWAYS TAKEN
 2004ab4:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
        }                                                             
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
 2004ab8:	10 80 00 28 	b  2004b58 <read_extended_partition+0x188>     <== NOT EXECUTED
 2004abc:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          <== NOT EXECUTED
        {                                                             
            free(sector);                                             
            return rc;                                                
        }                                                             
                                                                      
        if (new_part_desc == NULL)                                    
 2004ac0:	80 a2 a0 00 	cmp  %o2, 0                                    
 2004ac4:	22 80 00 21 	be,a   2004b48 <read_extended_partition+0x178> 
 2004ac8:	b8 07 20 04 	add  %i4, 4, %i4                               
        {                                                             
            data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;              
            continue;                                                 
        }                                                             
                                                                      
        ext_part->sub_part[i] = new_part_desc;                        
 2004acc:	d4 27 20 18 	st  %o2, [ %i4 + 0x18 ]                        
        new_part_desc->ext_part = ext_part;                           
        new_part_desc->disk_desc = ext_part->disk_desc;               
 2004ad0:	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));
 2004ad4:	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;                           
 2004ad8:	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))                     
 2004adc:	84 08 a0 7f 	and  %g2, 0x7f, %g2                            
            continue;                                                 
        }                                                             
                                                                      
        ext_part->sub_part[i] = new_part_desc;                        
        new_part_desc->ext_part = ext_part;                           
        new_part_desc->disk_desc = ext_part->disk_desc;               
 2004ae0:	c2 22 a0 10 	st  %g1, [ %o2 + 0x10 ]                        
                                                                      
        if (is_extended(new_part_desc->sys_type))                     
 2004ae4:	80 a0 a0 05 	cmp  %g2, 5                                    
 2004ae8:	12 80 00 0a 	bne  2004b10 <read_extended_partition+0x140>   
 2004aec:	c4 02 a0 04 	ld  [ %o2 + 4 ], %g2                           
        {                                                             
            new_part_desc->log_id = EMPTY_PARTITION;                  
            new_part_desc->start += start;                            
 2004af0:	84 00 80 19 	add  %g2, %i1, %g2                             
        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;                  
 2004af4:	c0 2a a0 02 	clrb  [ %o2 + 2 ]                              
            new_part_desc->start += start;                            
 2004af8:	c4 22 a0 04 	st  %g2, [ %o2 + 4 ]                           
            read_extended_partition(fd, start, new_part_desc);        
 2004afc:	90 10 00 18 	mov  %i0, %o0                                  
 2004b00:	7f ff ff b4 	call  20049d0 <read_extended_partition>        
 2004b04:	92 10 00 19 	mov  %i1, %o1                                  
 2004b08:	10 80 00 10 	b  2004b48 <read_extended_partition+0x178>     
 2004b0c:	b8 07 20 04 	add  %i4, 4, %i4                               
        }                                                             
        else                                                          
        {                                                             
            rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;  
            disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
 2004b10:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
 2004b14:	88 00 e0 0a 	add  %g3, 0xa, %g4                             
            new_part_desc->log_id = ++disk_desc->last_log_id;         
 2004b18:	86 00 e0 01 	inc  %g3                                       
            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;
 2004b1c:	89 29 20 02 	sll  %g4, 2, %g4                               
            new_part_desc->log_id = ++disk_desc->last_log_id;         
 2004b20:	c6 20 60 24 	st  %g3, [ %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;
 2004b24:	d4 20 40 04 	st  %o2, [ %g1 + %g4 ]                         
            new_part_desc->log_id = ++disk_desc->last_log_id;         
            new_part_desc->start += here;                             
 2004b28:	82 06 c0 02 	add  %i3, %g2, %g1                             
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
 2004b2c:	c4 02 a0 08 	ld  [ %o2 + 8 ], %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;                             
 2004b30:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
 2004b34:	84 00 bf ff 	add  %g2, -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;         
 2004b38:	c6 2a a0 02 	stb  %g3, [ %o2 + 2 ]                          
            new_part_desc->start += here;                             
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
 2004b3c:	82 00 80 01 	add  %g2, %g1, %g1                             
 2004b40:	c2 22 a0 0c 	st  %g1, [ %o2 + 0xc ]                         
 2004b44:	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++)
 2004b48:	80 a7 00 11 	cmp  %i4, %l1                                  
 2004b4c:	12 bf ff d5 	bne  2004aa0 <read_extended_partition+0xd0>    
 2004b50:	a0 04 20 10 	add  %l0, 0x10, %l0                            
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
        }                                                             
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
 2004b54:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
 2004b58:	40 00 03 4c 	call  2005888 <free>                           
 2004b5c:	01 00 00 00 	nop                                            
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
 2004b60:	b0 10 00 1d 	mov  %i5, %i0                                  
 2004b64:	81 c7 e0 08 	ret                                            
 2004b68:	81 e8 00 00 	restore                                        
                                                                      

020050e0 <readv>: ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) {
 20050e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int            v;                                                   
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
 20050e4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20050e8:	c2 00 60 f4 	ld  [ %g1 + 0xf4 ], %g1	! 201d4f4 <rtems_libio_number_iops>
 20050ec:	80 a6 00 01 	cmp  %i0, %g1                                  
 20050f0:	2a 80 00 03 	bcs,a   20050fc <readv+0x1c>                   
 20050f4:	83 2e 20 03 	sll  %i0, 3, %g1                               
 20050f8:	30 80 00 0c 	b,a   2005128 <readv+0x48>                     
  iop = rtems_libio_iop( fd );                                        
 20050fc:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2005100:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2005104:	03 00 80 77 	sethi  %hi(0x201dc00), %g1                     
 2005108:	f8 00 63 44 	ld  [ %g1 + 0x344 ], %i4	! 201df44 <rtems_libio_iops>
 200510c:	b8 07 00 18 	add  %i4, %i0, %i4                             
  rtems_libio_check_is_open( iop );                                   
 2005110:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
 2005114:	80 88 61 00 	btst  0x100, %g1                               
 2005118:	02 80 00 04 	be  2005128 <readv+0x48>                       
 200511c:	80 88 60 02 	btst  2, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
 2005120:	12 80 00 06 	bne  2005138 <readv+0x58>                      <== ALWAYS TAKEN
 2005124:	80 a6 60 00 	cmp  %i1, 0                                    
 2005128:	40 00 2c a0 	call  20103a8 <__errno>                        
 200512c:	01 00 00 00 	nop                                            
 2005130:	10 80 00 1a 	b  2005198 <readv+0xb8>                        
 2005134:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
 2005138:	02 80 00 15 	be  200518c <readv+0xac>                       
 200513c:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
 2005140:	04 80 00 13 	ble  200518c <readv+0xac>                      
 2005144:	80 a6 a4 00 	cmp  %i2, 0x400                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
 2005148:	24 80 00 03 	ble,a   2005154 <readv+0x74>                   <== ALWAYS TAKEN
 200514c:	b5 2e a0 03 	sll  %i2, 3, %i2                               
 2005150:	30 80 00 0f 	b,a   200518c <readv+0xac>                     <== NOT EXECUTED
 *                                                                    
 *  OpenGroup URL:                                                    
 *                                                                    
 *  http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
 */                                                                   
ssize_t readv(                                                        
 2005154:	82 10 20 00 	clr  %g1                                       
 2005158:	84 10 20 01 	mov  1, %g2                                    
 200515c:	10 80 00 03 	b  2005168 <readv+0x88>                        
 2005160:	86 10 20 00 	clr  %g3                                       
    if ( iov[v].iov_base == 0 )                                       
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
 2005164:	86 10 00 1d 	mov  %i5, %g3                                  
                                                                      
    /*                                                                
     *  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 )                                       
 2005168:	c8 06 40 01 	ld  [ %i1 + %g1 ], %g4                         
 200516c:	80 a1 20 00 	cmp  %g4, 0                                    
 2005170:	02 80 00 07 	be  200518c <readv+0xac>                       
 2005174:	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;                                          
 2005178:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
 200517c:	ba 01 00 03 	add  %g4, %g3, %i5                             
    if ( total < old )                                                
 2005180:	80 a7 40 03 	cmp  %i5, %g3                                  
 2005184:	16 80 00 07 	bge  20051a0 <readv+0xc0>                      
 2005188:	80 a0 00 04 	cmp  %g0, %g4                                  
      rtems_set_errno_and_return_minus_one( EINVAL );                 
 200518c:	40 00 2c 87 	call  20103a8 <__errno>                        
 2005190:	01 00 00 00 	nop                                            
 2005194:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2005198:	10 80 00 20 	b  2005218 <readv+0x138>                       
 200519c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 20051a0:	82 00 60 08 	add  %g1, 8, %g1                               
                                                                      
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
 20051a4:	86 40 3f ff 	addx  %g0, -1, %g3                             
   *  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++ ) {                           
 20051a8:	80 a0 40 1a 	cmp  %g1, %i2                                  
 20051ac:	12 bf ff ee 	bne  2005164 <readv+0x84>                      
 20051b0:	84 08 80 03 	and  %g2, %g3, %g2                             
  /*                                                                  
   *  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 ) {                                          
 20051b4:	80 88 a0 ff 	btst  0xff, %g2                                
 20051b8:	12 80 00 16 	bne  2005210 <readv+0x130>                     
 20051bc:	b0 10 20 00 	clr  %i0                                       
 20051c0:	ba 10 20 00 	clr  %i5                                       
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    bytes = (*iop->pathinfo.handlers->read_h)(                        
 20051c4:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
 *                                                                    
 *  OpenGroup URL:                                                    
 *                                                                    
 *  http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
 */                                                                   
ssize_t readv(                                                        
 20051c8:	b6 06 40 1d 	add  %i1, %i5, %i3                             
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    bytes = (*iop->pathinfo.handlers->read_h)(                        
 20051cc:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 20051d0:	d2 06 40 1d 	ld  [ %i1 + %i5 ], %o1                         
 20051d4:	d4 06 e0 04 	ld  [ %i3 + 4 ], %o2                           
 20051d8:	9f c0 40 00 	call  %g1                                      
 20051dc:	90 10 00 1c 	mov  %i4, %o0                                  
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
 20051e0:	80 a2 20 00 	cmp  %o0, 0                                    
 20051e4:	26 80 00 0b 	bl,a   2005210 <readv+0x130>                   <== NEVER TAKEN
 20051e8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
 20051ec:	32 80 00 02 	bne,a   20051f4 <readv+0x114>                  <== ALWAYS TAKEN
 20051f0:	b0 06 00 08 	add  %i0, %o0, %i0                             
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
 20051f4:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
 20051f8:	80 a2 00 01 	cmp  %o0, %g1                                  
 20051fc:	12 80 00 05 	bne  2005210 <readv+0x130>                     <== NEVER TAKEN
 2005200:	ba 07 60 08 	add  %i5, 8, %i5                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
 2005204:	80 a7 40 1a 	cmp  %i5, %i2                                  
 2005208:	32 bf ff f0 	bne,a   20051c8 <readv+0xe8>                   
 200520c:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
 2005210:	81 c7 e0 08 	ret                                            
 2005214:	81 e8 00 00 	restore                                        
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
      return -1;                                                      
 2005218:	b0 10 3f ff 	mov  -1, %i0                                   
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
 200521c:	81 c7 e0 08 	ret                                            
 2005220:	81 e8 00 00 	restore                                        
                                                                      

02004418 <realloc>: void *realloc( void *ptr, size_t size ) {
 2004418:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
 200441c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2004420:	82 10 60 50 	or  %g1, 0x50, %g1	! 201d450 <rtems_malloc_statistics>
 2004424:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 2004428:	84 00 a0 01 	inc  %g2                                       
 200442c:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if in a critical section or ISR.
   */                                                                 
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
 2004430:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
 2004434:	c2 00 62 e8 	ld  [ %g1 + 0x2e8 ], %g1	! 201dae8 <_System_state_Current>
 2004438:	80 a0 60 03 	cmp  %g1, 3                                    
 200443c:	12 80 00 09 	bne  2004460 <realloc+0x48>                    
 2004440:	80 a6 20 00 	cmp  %i0, 0                                    
   * 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 )                      
 2004444:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2004448:	c2 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g1	! 201d5d0 <_Thread_Dispatch_disable_level>
 200444c:	80 a0 60 00 	cmp  %g1, 0                                    
 2004450:	02 80 00 38 	be  2004530 <realloc+0x118>                    <== ALWAYS TAKEN
 2004454:	03 00 80 76 	sethi  %hi(0x201d800), %g1                     
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
    errno = EINVAL;                                                   
    return (void *) 0;                                                
 2004458:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200445c:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
 2004460:	12 80 00 04 	bne  2004470 <realloc+0x58>                    
 2004464:	80 a6 60 00 	cmp  %i1, 0                                    
    return malloc( size );                                            
 2004468:	7f ff fd 26 	call  2003900 <malloc>                         
 200446c:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                                                      
  if ( !size ) {                                                      
 2004470:	12 80 00 06 	bne  2004488 <realloc+0x70>                    <== ALWAYS TAKEN
 2004474:	3b 00 80 72 	sethi  %hi(0x201c800), %i5                     
    free( ptr );                                                      
 2004478:	7f ff fc 4e 	call  20035b0 <free>                           <== NOT EXECUTED
 200447c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
    errno = EINVAL;                                                   
    return (void *) 0;                                                
 2004480:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004484:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
  if ( !size ) {                                                      
    free( ptr );                                                      
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
 2004488:	d0 07 61 b0 	ld  [ %i5 + 0x1b0 ], %o0                       
 200448c:	92 10 00 18 	mov  %i0, %o1                                  
 2004490:	40 00 13 e5 	call  2009424 <_Protected_heap_Get_block_size> 
 2004494:	94 07 bf fc 	add  %fp, -4, %o2                              
 2004498:	80 8a 20 ff 	btst  0xff, %o0                                
 200449c:	12 80 00 08 	bne  20044bc <realloc+0xa4>                    
 20044a0:	d0 07 61 b0 	ld  [ %i5 + 0x1b0 ], %o0                       
    errno = EINVAL;                                                   
 20044a4:	40 00 2c 72 	call  200f66c <__errno>                        
 20044a8:	01 00 00 00 	nop                                            
 20044ac:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 20044b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return (void *) 0;                                                
 20044b4:	81 c7 e0 08 	ret                                            
 20044b8:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
                                                                      
  /*                                                                  
   *  Now resize it.                                                  
   */                                                                 
  if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
 20044bc:	92 10 00 18 	mov  %i0, %o1                                  
 20044c0:	40 00 13 e9 	call  2009464 <_Protected_heap_Resize_block>   
 20044c4:	94 10 00 19 	mov  %i1, %o2                                  
 20044c8:	80 8a 20 ff 	btst  0xff, %o0                                
 20044cc:	12 80 00 1e 	bne  2004544 <realloc+0x12c>                   
 20044d0:	01 00 00 00 	nop                                            
   *  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 );                                          
 20044d4:	7f ff fd 0b 	call  2003900 <malloc>                         
 20044d8:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
 20044dc:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20044e0:	82 10 60 50 	or  %g1, 0x50, %g1	! 201d450 <rtems_malloc_statistics>
 20044e4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
   *  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 );                                          
 20044e8:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
 20044ec:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
  if ( !new_area ) {                                                  
 20044f0:	80 a2 20 00 	cmp  %o0, 0                                    
 20044f4:	02 bf ff f0 	be  20044b4 <realloc+0x9c>                     
 20044f8:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
 20044fc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2004500:	80 a6 40 01 	cmp  %i1, %g1                                  
 2004504:	08 80 00 03 	bleu  2004510 <realloc+0xf8>                   <== NEVER TAKEN
 2004508:	94 10 00 19 	mov  %i1, %o2                                  
 200450c:	94 10 00 01 	mov  %g1, %o2                                  
 2004510:	92 10 00 18 	mov  %i0, %o1                                  
 2004514:	40 00 2e a7 	call  200ffb0 <memcpy>                         
 2004518:	90 10 00 1d 	mov  %i5, %o0                                  
  free( ptr );                                                        
 200451c:	90 10 00 18 	mov  %i0, %o0                                  
 2004520:	7f ff fc 24 	call  20035b0 <free>                           
 2004524:	b0 10 00 1d 	mov  %i5, %i0                                  
 2004528:	81 c7 e0 08 	ret                                            
 200452c:	81 e8 00 00 	restore                                        
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_in_critical_section())                       
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
 2004530:	c2 00 62 f8 	ld  [ %g1 + 0x2f8 ], %g1                       
 2004534:	80 a0 60 00 	cmp  %g1, 0                                    
 2004538:	02 bf ff ca 	be  2004460 <realloc+0x48>                     <== ALWAYS TAKEN
 200453c:	80 a6 20 00 	cmp  %i0, 0                                    
 2004540:	30 bf ff dd 	b,a   20044b4 <realloc+0x9c>                   <== NOT EXECUTED
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
  free( ptr );                                                        
                                                                      
  return new_area;                                                    
                                                                      
}                                                                     
 2004544:	81 c7 e0 08 	ret                                            
 2004548:	81 e8 00 00 	restore                                        
                                                                      

02007ed8 <rtems_aio_enqueue>: * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) {
 2007ed8:	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);             
 2007edc:	37 00 80 7e 	sethi  %hi(0x201f800), %i3                     
 *         errno     - otherwise                                      
 */                                                                   
                                                                      
int                                                                   
rtems_aio_enqueue (rtems_aio_request *req)                            
{                                                                     
 2007ee0:	ba 10 00 18 	mov  %i0, %i5                                  
  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);             
 2007ee4:	40 00 02 85 	call  20088f8 <pthread_mutex_lock>             
 2007ee8:	90 16 e1 bc 	or  %i3, 0x1bc, %o0                            
  if (result != 0) {                                                  
 2007eec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2007ef0:	02 80 00 06 	be  2007f08 <rtems_aio_enqueue+0x30>           <== ALWAYS TAKEN
 2007ef4:	01 00 00 00 	nop                                            
    free (req);                                                       
 2007ef8:	7f ff ef 0f 	call  2003b34 <free>                           <== NOT EXECUTED
 2007efc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2007f00:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2007f04:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    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);            
 2007f08:	40 00 04 90 	call  2009148 <pthread_self>                   
 2007f0c:	b6 16 e1 bc 	or  %i3, 0x1bc, %i3                            
 2007f10:	92 07 bf e0 	add  %fp, -32, %o1                             
 2007f14:	40 00 03 9d 	call  2008d88 <pthread_getschedparam>          
 2007f18:	94 07 bf e4 	add  %fp, -28, %o2                             
                                                                      
  req->caller_thread = pthread_self ();                               
 2007f1c:	40 00 04 8b 	call  2009148 <pthread_self>                   
 2007f20:	01 00 00 00 	nop                                            
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
 2007f24:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2007f28:	c6 07 bf e4 	ld  [ %fp + -28 ], %g3                         
 2007f2c:	c4 00 60 18 	ld  [ %g1 + 0x18 ], %g2                        
                                                                      
  /* _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 ();                               
 2007f30:	d0 27 60 10 	st  %o0, [ %i5 + 0x10 ]                        
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
 2007f34:	84 20 c0 02 	sub  %g3, %g2, %g2                             
 2007f38:	c4 27 60 0c 	st  %g2, [ %i5 + 0xc ]                         
  req->policy = policy;                                               
 2007f3c:	c4 07 bf e0 	ld  [ %fp + -32 ], %g2                         
 2007f40:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
  req->aiocbp->error_code = EINPROGRESS;                              
 2007f44:	84 10 20 77 	mov  0x77, %g2                                 
 2007f48:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
  req->aiocbp->return_value = 0;                                      
                                                                      
  if ((aio_request_queue.idle_threads == 0) &&                        
 2007f4c:	c4 06 e0 68 	ld  [ %i3 + 0x68 ], %g2                        
                                                                      
  req->caller_thread = pthread_self ();                               
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
  req->policy = policy;                                               
  req->aiocbp->error_code = EINPROGRESS;                              
  req->aiocbp->return_value = 0;                                      
 2007f50:	c0 20 60 38 	clr  [ %g1 + 0x38 ]                            
                                                                      
  if ((aio_request_queue.idle_threads == 0) &&                        
 2007f54:	80 a0 a0 00 	cmp  %g2, 0                                    
 2007f58:	12 80 00 2e 	bne  2008010 <rtems_aio_enqueue+0x138>         <== NEVER TAKEN
 2007f5c:	d2 00 40 00 	ld  [ %g1 ], %o1                               
 2007f60:	c2 06 e0 64 	ld  [ %i3 + 0x64 ], %g1                        
 2007f64:	80 a0 60 04 	cmp  %g1, 4                                    
 2007f68:	14 80 00 2b 	bg  2008014 <rtems_aio_enqueue+0x13c>          
 2007f6c:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
      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);
 2007f70:	90 06 e0 48 	add  %i3, 0x48, %o0                            
 2007f74:	7f ff ff 7d 	call  2007d68 <rtems_aio_search_fd>            
 2007f78:	94 10 20 01 	mov  1, %o2                                    
                                                                      
      if (r_chain->new_fd == 1) {                                     
 2007f7c:	c2 02 20 18 	ld  [ %o0 + 0x18 ], %g1                        
  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);
 2007f80:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
      if (r_chain->new_fd == 1) {                                     
 2007f84:	80 a0 60 01 	cmp  %g1, 1                                    
 2007f88:	12 80 00 1d 	bne  2007ffc <rtems_aio_enqueue+0x124>         
 2007f8c:	b4 02 20 08 	add  %o0, 8, %i2                               
RTEMS_INLINE_ROUTINE void _Chain_Prepend(                             
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  _Chain_Insert(_Chain_Head(the_chain), the_node);                    
 2007f90:	92 10 00 1d 	mov  %i5, %o1                                  
 2007f94:	40 00 09 15 	call  200a3e8 <_Chain_Insert>                  
 2007f98:	90 10 00 1a 	mov  %i2, %o0                                  
	rtems_chain_prepend (&r_chain->perfd, &req->next_prio);              
	r_chain->new_fd = 0;                                                 
	pthread_mutex_init (&r_chain->mutex, NULL);                          
 2007f9c:	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;                                                 
 2007fa0:	c0 27 20 18 	clr  [ %i4 + 0x18 ]                            
	pthread_mutex_init (&r_chain->mutex, NULL);                          
 2007fa4:	40 00 01 fd 	call  2008798 <pthread_mutex_init>             
 2007fa8:	90 07 20 1c 	add  %i4, 0x1c, %o0                            
	pthread_cond_init (&r_chain->cond, NULL);                            
 2007fac:	92 10 20 00 	clr  %o1                                       
 2007fb0:	40 00 00 ff 	call  20083ac <pthread_cond_init>              
 2007fb4:	90 07 20 20 	add  %i4, 0x20, %o0                            
	                                                                     
	AIO_printf ("New thread \n");                                        
	result = pthread_create (&thid, &aio_request_queue.attr,             
 2007fb8:	90 07 bf dc 	add  %fp, -36, %o0                             
 2007fbc:	92 06 e0 08 	add  %i3, 8, %o1                               
 2007fc0:	15 00 80 1e 	sethi  %hi(0x2007800), %o2                     
 2007fc4:	96 10 00 1c 	mov  %i4, %o3                                  
 2007fc8:	40 00 02 df 	call  2008b44 <pthread_create>                 
 2007fcc:	94 12 a1 b0 	or  %o2, 0x1b0, %o2                            
				 rtems_aio_handle, (void *) r_chain);                             
	if (result != 0) {                                                   
 2007fd0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2007fd4:	22 80 00 07 	be,a   2007ff0 <rtems_aio_enqueue+0x118>       <== ALWAYS TAKEN
 2007fd8:	c2 06 e0 64 	ld  [ %i3 + 0x64 ], %g1                        
	  pthread_mutex_unlock (&aio_request_queue.mutex);                   
 2007fdc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
 2007fe0:	40 00 02 67 	call  200897c <pthread_mutex_unlock>           <== NOT EXECUTED
 2007fe4:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 2007fe8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2007fec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
	  return result;                                                     
	}                                                                    
	++aio_request_queue.active_threads;                                  
 2007ff0:	82 00 60 01 	inc  %g1                                       
 2007ff4:	10 80 00 3a 	b  20080dc <rtems_aio_enqueue+0x204>           
 2007ff8:	c2 26 e0 64 	st  %g1, [ %i3 + 0x64 ]                        
      }                                                               
      else {                                                          
	/* put request in the fd chain it belongs to */                      
	pthread_mutex_lock (&r_chain->mutex);                                
 2007ffc:	b6 02 20 1c 	add  %o0, 0x1c, %i3                            
 2008000:	40 00 02 3e 	call  20088f8 <pthread_mutex_lock>             
 2008004:	90 10 00 1b 	mov  %i3, %o0                                  
	rtems_aio_insert_prio (&r_chain->perfd, req);                        
 2008008:	10 80 00 0c 	b  2008038 <rtems_aio_enqueue+0x160>           
 200800c:	90 10 00 1a 	mov  %i2, %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,     
 2008010:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     <== NOT EXECUTED
 2008014:	94 10 20 00 	clr  %o2                                       
 2008018:	7f ff ff 54 	call  2007d68 <rtems_aio_search_fd>            
 200801c:	90 12 22 04 	or  %o0, 0x204, %o0                            
				     req->aiocbp->aio_fildes, 0);                                 
      if (r_chain != NULL)                                            
 2008020:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2008024:	02 80 00 0d 	be  2008058 <rtems_aio_enqueue+0x180>          
 2008028:	b6 07 20 1c 	add  %i4, 0x1c, %i3                            
	{                                                                    
	  pthread_mutex_lock (&r_chain->mutex);                              
 200802c:	40 00 02 33 	call  20088f8 <pthread_mutex_lock>             
 2008030:	90 10 00 1b 	mov  %i3, %o0                                  
	  rtems_aio_insert_prio (&r_chain->perfd, req);                      
 2008034:	90 07 20 08 	add  %i4, 8, %o0                               
 2008038:	7f ff fe fc 	call  2007c28 <rtems_aio_insert_prio>          
 200803c:	92 10 00 1d 	mov  %i5, %o1                                  
	  pthread_cond_signal (&r_chain->cond);                              
 2008040:	40 00 01 0a 	call  2008468 <pthread_cond_signal>            
 2008044:	90 07 20 20 	add  %i4, 0x20, %o0                            
	  pthread_mutex_unlock (&r_chain->mutex);                            
 2008048:	40 00 02 4d 	call  200897c <pthread_mutex_unlock>           
 200804c:	90 10 00 1b 	mov  %i3, %o0                                  
	if (aio_request_queue.idle_threads > 0)                              
	  pthread_cond_signal (&aio_request_queue.new_req);                  
      }                                                               
    }                                                                 
                                                                      
  pthread_mutex_unlock (&aio_request_queue.mutex);                    
 2008050:	10 80 00 24 	b  20080e0 <rtems_aio_enqueue+0x208>           
 2008054:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
	                                                                     
	} else {                                                             
                                                                      
	/* or to the idle chain */                                           
	chain = &aio_request_queue.idle_req;                                 
	r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);   
 2008058:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200805c:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
 2008060:	d2 00 40 00 	ld  [ %g1 ], %o1                               
 2008064:	90 12 22 10 	or  %o0, 0x210, %o0                            
 2008068:	7f ff ff 40 	call  2007d68 <rtems_aio_search_fd>            
 200806c:	94 10 20 01 	mov  1, %o2                                    
                                                                      
	if (r_chain->new_fd == 1) {                                          
 2008070:	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);   
 2008074:	b8 10 00 08 	mov  %o0, %i4                                  
 2008078:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
	if (r_chain->new_fd == 1) {                                          
 200807c:	80 a0 60 01 	cmp  %g1, 1                                    
 2008080:	12 80 00 0d 	bne  20080b4 <rtems_aio_enqueue+0x1dc>         
 2008084:	90 02 20 08 	add  %o0, 8, %o0                               
 2008088:	40 00 08 d8 	call  200a3e8 <_Chain_Insert>                  
 200808c:	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);                        
 2008090:	90 07 20 1c 	add  %i4, 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;                                               
 2008094:	c0 27 20 18 	clr  [ %i4 + 0x18 ]                            
	  pthread_mutex_init (&r_chain->mutex, NULL);                        
 2008098:	40 00 01 c0 	call  2008798 <pthread_mutex_init>             
 200809c:	92 10 20 00 	clr  %o1                                       
	  pthread_cond_init (&r_chain->cond, NULL);                          
 20080a0:	90 07 20 20 	add  %i4, 0x20, %o0                            
 20080a4:	40 00 00 c2 	call  20083ac <pthread_cond_init>              
 20080a8:	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)                              
 20080ac:	10 80 00 05 	b  20080c0 <rtems_aio_enqueue+0x1e8>           
 20080b0:	11 00 80 7e 	sethi  %hi(0x201f800), %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);                      
 20080b4:	7f ff fe dd 	call  2007c28 <rtems_aio_insert_prio>          
 20080b8:	01 00 00 00 	nop                                            
	if (aio_request_queue.idle_threads > 0)                              
 20080bc:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
 20080c0:	90 12 21 bc 	or  %o0, 0x1bc, %o0	! 201f9bc <aio_request_queue>
 20080c4:	c2 02 20 68 	ld  [ %o0 + 0x68 ], %g1                        
 20080c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20080cc:	24 80 00 05 	ble,a   20080e0 <rtems_aio_enqueue+0x208>      <== ALWAYS TAKEN
 20080d0:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
	  pthread_cond_signal (&aio_request_queue.new_req);                  
 20080d4:	40 00 00 e5 	call  2008468 <pthread_cond_signal>            <== NOT EXECUTED
 20080d8:	90 02 20 04 	add  %o0, 4, %o0	! 201f804 <__nlocale_changed> <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
  pthread_mutex_unlock (&aio_request_queue.mutex);                    
 20080dc:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
 20080e0:	40 00 02 27 	call  200897c <pthread_mutex_unlock>           
 20080e4:	90 12 21 bc 	or  %o0, 0x1bc, %o0	! 201f9bc <aio_request_queue>
  return 0;                                                           
}                                                                     
 20080e8:	81 c7 e0 08 	ret                                            
 20080ec:	81 e8 00 00 	restore                                        
                                                                      

020079b0 <rtems_aio_handle>: * NULL - if error */ static void * rtems_aio_handle (void *arg) {
 20079b0:	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);                  
 20079b4:	3b 00 80 7e 	sethi  %hi(0x201f800), %i5                     
 20079b8:	ba 17 61 bc 	or  %i5, 0x1bc, %i5	! 201f9bc <aio_request_queue>
	    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)) {        
 20079bc:	b4 07 60 58 	add  %i5, 0x58, %i2                            
  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 &&                            
 20079c0:	b2 07 60 4c 	add  %i5, 0x4c, %i1                            
	      --aio_request_queue.active_threads;                            
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
	      timeout.tv_sec += 3;                                           
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
 20079c4:	a0 07 60 04 	add  %i5, 4, %l0                               
    /* 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);                    
 20079c8:	b6 06 20 1c 	add  %i0, 0x1c, %i3                            
 20079cc:	40 00 03 cb 	call  20088f8 <pthread_mutex_lock>             
 20079d0:	90 10 00 1b 	mov  %i3, %o0                                  
    if (result != 0)                                                  
 20079d4:	80 a2 20 00 	cmp  %o0, 0                                    
 20079d8:	12 80 00 91 	bne  2007c1c <rtems_aio_handle+0x26c>          <== NEVER TAKEN
 20079dc:	82 06 20 0c 	add  %i0, 0xc, %g1                             
 20079e0:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
                                                                      
    /* 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)) {                              
 20079e4:	80 a7 00 01 	cmp  %i4, %g1                                  
 20079e8:	02 80 00 3b 	be  2007ad4 <rtems_aio_handle+0x124>           
 20079ec:	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);        
 20079f0:	40 00 05 d6 	call  2009148 <pthread_self>                   
 20079f4:	01 00 00 00 	nop                                            
 20079f8:	92 07 bf d8 	add  %fp, -40, %o1                             
 20079fc:	40 00 04 e3 	call  2008d88 <pthread_getschedparam>          
 2007a00:	94 07 bf e4 	add  %fp, -28, %o2                             
      param.sched_priority = req->priority;                           
 2007a04:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
      pthread_setschedparam (pthread_self(), req->policy, ¶m);    
 2007a08:	40 00 05 d0 	call  2009148 <pthread_self>                   
 2007a0c:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]                         
 2007a10:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
 2007a14:	40 00 05 d1 	call  2009158 <pthread_setschedparam>          
 2007a18:	94 07 bf e4 	add  %fp, -28, %o2                             
 2007a1c:	40 00 0a 5a 	call  200a384 <_Chain_Extract>                 
 2007a20:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
      rtems_chain_extract (node);                                     
                                                                      
      pthread_mutex_unlock (&r_chain->mutex);                         
 2007a24:	40 00 03 d6 	call  200897c <pthread_mutex_unlock>           
 2007a28:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
      switch (req->aiocbp->aio_lio_opcode) {                          
 2007a2c:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
 2007a30:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2                        
 2007a34:	80 a0 a0 02 	cmp  %g2, 2                                    
 2007a38:	22 80 00 10 	be,a   2007a78 <rtems_aio_handle+0xc8>         
 2007a3c:	c4 18 60 08 	ldd  [ %g1 + 8 ], %g2                          
 2007a40:	80 a0 a0 03 	cmp  %g2, 3                                    
 2007a44:	02 80 00 15 	be  2007a98 <rtems_aio_handle+0xe8>            <== NEVER TAKEN
 2007a48:	80 a0 a0 01 	cmp  %g2, 1                                    
 2007a4c:	32 80 00 19 	bne,a   2007ab0 <rtems_aio_handle+0x100>       <== NEVER TAKEN
 2007a50:	f8 07 20 14 	ld  [ %i4 + 0x14 ], %i4                        <== NOT EXECUTED
      case LIO_READ:                                                  
	AIO_printf ("read\n");                                               
        result = pread (req->aiocbp->aio_fildes,                      
 2007a54:	c4 18 60 08 	ldd  [ %g1 + 8 ], %g2                          
 2007a58:	d0 00 40 00 	ld  [ %g1 ], %o0                               
 2007a5c:	d2 00 60 10 	ld  [ %g1 + 0x10 ], %o1                        
 2007a60:	d4 00 60 14 	ld  [ %g1 + 0x14 ], %o2                        
 2007a64:	96 10 00 02 	mov  %g2, %o3                                  
 2007a68:	40 00 2a d0 	call  20125a8 <pread>                          
 2007a6c:	98 10 00 03 	mov  %g3, %o4                                  
                        (void *) req->aiocbp->aio_buf,                
                        req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
        break;                                                        
 2007a70:	10 80 00 0d 	b  2007aa4 <rtems_aio_handle+0xf4>             
 2007a74:	80 a2 3f ff 	cmp  %o0, -1                                   
                                                                      
      case LIO_WRITE:                                                 
	AIO_printf ("write\n");                                              
        result = pwrite (req->aiocbp->aio_fildes,                     
 2007a78:	d0 00 40 00 	ld  [ %g1 ], %o0                               
 2007a7c:	d2 00 60 10 	ld  [ %g1 + 0x10 ], %o1                        
 2007a80:	d4 00 60 14 	ld  [ %g1 + 0x14 ], %o2                        
 2007a84:	96 10 00 02 	mov  %g2, %o3                                  
 2007a88:	40 00 2b 06 	call  20126a0 <pwrite>                         
 2007a8c:	98 10 00 03 	mov  %g3, %o4                                  
                         (void *) req->aiocbp->aio_buf,               
                         req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
        break;                                                        
 2007a90:	10 80 00 05 	b  2007aa4 <rtems_aio_handle+0xf4>             
 2007a94:	80 a2 3f ff 	cmp  %o0, -1                                   
                                                                      
      case LIO_SYNC:                                                  
	AIO_printf ("sync\n");                                               
      	result = fsync (req->aiocbp->aio_fildes);                      
 2007a98:	40 00 1a a8 	call  200e538 <fsync>                          <== NOT EXECUTED
 2007a9c:	d0 00 40 00 	ld  [ %g1 ], %o0                               <== NOT EXECUTED
      	break;                                                         
                                                                      
      default:                                                        
        result = -1;                                                  
      }                                                               
      if (result == -1) {                                             
 2007aa0:	80 a2 3f ff 	cmp  %o0, -1                                   <== NOT EXECUTED
 2007aa4:	32 80 00 09 	bne,a   2007ac8 <rtems_aio_handle+0x118>       <== ALWAYS TAKEN
 2007aa8:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
        req->aiocbp->return_value = -1;                               
 2007aac:	f8 07 20 14 	ld  [ %i4 + 0x14 ], %i4                        <== NOT EXECUTED
 2007ab0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
	req->aiocbp->error_code = errno;                                     
 2007ab4:	40 00 27 b7 	call  2011990 <__errno>                        <== NOT EXECUTED
 2007ab8:	c2 27 20 38 	st  %g1, [ %i4 + 0x38 ]                        <== NOT EXECUTED
 2007abc:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
 2007ac0:	10 bf ff c2 	b  20079c8 <rtems_aio_handle+0x18>             <== NOT EXECUTED
 2007ac4:	c2 27 20 34 	st  %g1, [ %i4 + 0x34 ]                        <== NOT EXECUTED
      } else {                                                        
        req->aiocbp->return_value = result;                           
 2007ac8:	d0 20 60 38 	st  %o0, [ %g1 + 0x38 ]                        
        req->aiocbp->error_code = 0;                                  
 2007acc:	10 bf ff bf 	b  20079c8 <rtems_aio_handle+0x18>             
 2007ad0:	c0 20 60 34 	clr  [ %g1 + 0x34 ]                            
                                                                      
      struct timespec timeout;                                        
                                                                      
      AIO_printf ("Chain is empty [WQ], wait for work\n");            
                                                                      
      pthread_mutex_unlock (&r_chain->mutex);                         
 2007ad4:	40 00 03 aa 	call  200897c <pthread_mutex_unlock>           
 2007ad8:	90 10 00 1b 	mov  %i3, %o0                                  
      pthread_mutex_lock (&aio_request_queue.mutex);                  
 2007adc:	40 00 03 87 	call  20088f8 <pthread_mutex_lock>             
 2007ae0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
 2007ae4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 2007ae8:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2007aec:	12 80 00 48 	bne  2007c0c <rtems_aio_handle+0x25c>          <== NEVER TAKEN
 2007af0:	92 07 bf dc 	add  %fp, -36, %o1                             
	{                                                                    
	  clock_gettime (CLOCK_REALTIME, &timeout);                          
 2007af4:	40 00 01 c9 	call  2008218 <clock_gettime>                  
 2007af8:	90 10 20 01 	mov  1, %o0                                    
	  timeout.tv_sec += 3;                                               
 2007afc:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
	  timeout.tv_nsec = 0;                                               
 2007b00:	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;                                               
 2007b04:	82 00 60 03 	add  %g1, 3, %g1                               
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
 2007b08:	b8 06 20 20 	add  %i0, 0x20, %i4                            
      pthread_mutex_lock (&aio_request_queue.mutex);                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
	{                                                                    
	  clock_gettime (CLOCK_REALTIME, &timeout);                          
	  timeout.tv_sec += 3;                                               
 2007b0c:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
 2007b10:	90 10 00 1c 	mov  %i4, %o0                                  
 2007b14:	92 10 00 1d 	mov  %i5, %o1                                  
 2007b18:	40 00 02 71 	call  20084dc <pthread_cond_timedwait>         
 2007b1c:	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) {                                         
 2007b20:	80 a2 20 74 	cmp  %o0, 0x74                                 
 2007b24:	12 80 00 3a 	bne  2007c0c <rtems_aio_handle+0x25c>          <== NEVER TAKEN
 2007b28:	01 00 00 00 	nop                                            
 2007b2c:	40 00 0a 16 	call  200a384 <_Chain_Extract>                 
 2007b30:	90 10 00 18 	mov  %i0, %o0                                  
	    rtems_chain_extract (&r_chain->next_fd);                         
	    pthread_mutex_destroy (&r_chain->mutex);                         
 2007b34:	40 00 02 c4 	call  2008644 <pthread_mutex_destroy>          
 2007b38:	90 10 00 1b 	mov  %i3, %o0                                  
	    pthread_cond_destroy (&r_chain->cond);                           
 2007b3c:	40 00 01 e5 	call  20082d0 <pthread_cond_destroy>           
 2007b40:	90 10 00 1c 	mov  %i4, %o0                                  
	    free (r_chain);                                                  
 2007b44:	7f ff ef fc 	call  2003b34 <free>                           
 2007b48:	90 10 00 18 	mov  %i0, %o0                                  
	                                                                     
	    /* 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)) {        
 2007b4c:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
 2007b50:	80 a0 40 1a 	cmp  %g1, %i2                                  
 2007b54:	12 80 00 1b 	bne  2007bc0 <rtems_aio_handle+0x210>          
 2007b58:	c2 07 60 68 	ld  [ %i5 + 0x68 ], %g1                        
	      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);                      
 2007b5c:	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;                              
 2007b60:	82 00 60 01 	inc  %g1                                       
 2007b64:	c2 27 60 68 	st  %g1, [ %i5 + 0x68 ]                        
	      --aio_request_queue.active_threads;                            
 2007b68:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
 2007b6c:	90 10 20 01 	mov  1, %o0                                    
	       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;                            
 2007b70:	82 00 7f ff 	add  %g1, -1, %g1                              
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
 2007b74:	40 00 01 a9 	call  2008218 <clock_gettime>                  
 2007b78:	c2 27 60 64 	st  %g1, [ %i5 + 0x64 ]                        
	      timeout.tv_sec += 3;                                           
 2007b7c:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
	      timeout.tv_nsec = 0;                                           
 2007b80:	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;                                           
 2007b84:	82 00 60 03 	add  %g1, 3, %g1                               
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
 2007b88:	90 10 00 10 	mov  %l0, %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;                                           
 2007b8c:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
 2007b90:	92 10 00 1d 	mov  %i5, %o1                                  
 2007b94:	40 00 02 52 	call  20084dc <pthread_cond_timedwait>         
 2007b98:	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) {                                     
 2007b9c:	80 a2 20 74 	cmp  %o0, 0x74                                 
 2007ba0:	12 80 00 08 	bne  2007bc0 <rtems_aio_handle+0x210>          <== NEVER TAKEN
 2007ba4:	c2 07 60 68 	ld  [ %i5 + 0x68 ], %g1                        
		AIO_printf ("Etimeout\n");                                          
		--aio_request_queue.idle_threads;                                   
		pthread_mutex_unlock (&aio_request_queue.mutex);                    
 2007ba8:	90 10 00 1d 	mov  %i5, %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;                                   
 2007bac:	82 00 7f ff 	add  %g1, -1, %g1                              
		pthread_mutex_unlock (&aio_request_queue.mutex);                    
 2007bb0:	40 00 03 73 	call  200897c <pthread_mutex_unlock>           
 2007bb4:	c2 27 60 68 	st  %g1, [ %i5 + 0x68 ]                        
    }                                                                 
  }                                                                   
                                                                      
  AIO_printf ("Thread finished\n");                                   
  return NULL;                                                        
}                                                                     
 2007bb8:	81 c7 e0 08 	ret                                            
 2007bbc:	91 e8 20 00 	restore  %g0, 0, %o0                           
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 2007bc0:	f0 07 60 54 	ld  [ %i5 + 0x54 ], %i0                        
	      }                                                              
	    }                                                                
	    /* 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;                                
 2007bc4:	82 00 7f ff 	add  %g1, -1, %g1                              
 2007bc8:	c2 27 60 68 	st  %g1, [ %i5 + 0x68 ]                        
	    ++aio_request_queue.active_threads;                              
 2007bcc:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
 2007bd0:	90 10 00 18 	mov  %i0, %o0                                  
 2007bd4:	82 00 60 01 	inc  %g1                                       
 2007bd8:	40 00 09 eb 	call  200a384 <_Chain_Extract>                 
 2007bdc:	c2 27 60 64 	st  %g1, [ %i5 + 0x64 ]                        
 2007be0:	c2 07 60 48 	ld  [ %i5 + 0x48 ], %g1                        
 2007be4:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
  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 &&                            
 2007be8:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
 2007bec:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2007bf0:	16 80 00 04 	bge  2007c00 <rtems_aio_handle+0x250>          
 2007bf4:	80 a0 40 19 	cmp  %g1, %i1                                  
 2007bf8:	32 bf ff fc 	bne,a   2007be8 <rtems_aio_handle+0x238>       <== ALWAYS TAKEN
 2007bfc:	c2 00 40 00 	ld  [ %g1 ], %g1                               
RTEMS_INLINE_ROUTINE void rtems_chain_insert(                         
  rtems_chain_node *after_node,                                       
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Insert( after_node, the_node );                              
 2007c00:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
 2007c04:	40 00 09 f9 	call  200a3e8 <_Chain_Insert>                  
 2007c08:	92 10 00 18 	mov  %i0, %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);                
 2007c0c:	40 00 03 5c 	call  200897c <pthread_mutex_unlock>           
 2007c10:	90 10 00 1d 	mov  %i5, %o0                                  
    /* 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);                    
 2007c14:	10 bf ff 6e 	b  20079cc <rtems_aio_handle+0x1c>             
 2007c18:	b6 06 20 1c 	add  %i0, 0x1c, %i3                            
    }                                                                 
  }                                                                   
                                                                      
  AIO_printf ("Thread finished\n");                                   
  return NULL;                                                        
}                                                                     
 2007c1c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 2007c20:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2007c24:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02007c88 <rtems_aio_init>: * 0 - if initialization succeeded */ int rtems_aio_init (void) {
 2007c88:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
                                                                      
  result = pthread_attr_init (&aio_request_queue.attr);               
 2007c8c:	3b 00 80 7e 	sethi  %hi(0x201f800), %i5                     
 2007c90:	40 00 03 93 	call  2008adc <pthread_attr_init>              
 2007c94:	90 17 61 c4 	or  %i5, 0x1c4, %o0	! 201f9c4 <aio_request_queue+0x8>
  if (result != 0)                                                    
 2007c98:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2007c9c:	12 80 00 31 	bne  2007d60 <rtems_aio_init+0xd8>             <== NEVER TAKEN
 2007ca0:	90 17 61 c4 	or  %i5, 0x1c4, %o0                            
    return result;                                                    
                                                                      
  result =                                                            
 2007ca4:	40 00 03 9a 	call  2008b0c <pthread_attr_setdetachstate>    
 2007ca8:	92 10 20 00 	clr  %o1                                       
    pthread_attr_setdetachstate (&aio_request_queue.attr,             
                                 PTHREAD_CREATE_DETACHED);            
  if (result != 0)                                                    
 2007cac:	80 a2 20 00 	cmp  %o0, 0                                    
 2007cb0:	22 80 00 05 	be,a   2007cc4 <rtems_aio_init+0x3c>           <== ALWAYS TAKEN
 2007cb4:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
    pthread_attr_destroy (&aio_request_queue.attr);                   
 2007cb8:	40 00 03 7d 	call  2008aac <pthread_attr_destroy>           <== NOT EXECUTED
 2007cbc:	90 17 61 c4 	or  %i5, 0x1c4, %o0                            <== NOT EXECUTED
                                                                      
                                                                      
  result = pthread_mutex_init (&aio_request_queue.mutex, NULL);       
 2007cc0:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     <== NOT EXECUTED
 2007cc4:	92 10 20 00 	clr  %o1                                       
 2007cc8:	40 00 02 b4 	call  2008798 <pthread_mutex_init>             
 2007ccc:	90 12 21 bc 	or  %o0, 0x1bc, %o0                            
  if (result != 0)                                                    
 2007cd0:	80 a2 20 00 	cmp  %o0, 0                                    
 2007cd4:	22 80 00 06 	be,a   2007cec <rtems_aio_init+0x64>           <== ALWAYS TAKEN
 2007cd8:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     
    pthread_attr_destroy (&aio_request_queue.attr);                   
 2007cdc:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     <== NOT EXECUTED
 2007ce0:	40 00 03 73 	call  2008aac <pthread_attr_destroy>           <== NOT EXECUTED
 2007ce4:	90 12 21 c4 	or  %o0, 0x1c4, %o0	! 201f9c4 <aio_request_queue+0x8><== NOT EXECUTED
                                                                      
                                                                      
  result = pthread_cond_init (&aio_request_queue.new_req, NULL);      
 2007ce8:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     <== NOT EXECUTED
 2007cec:	92 10 20 00 	clr  %o1                                       
 2007cf0:	40 00 01 af 	call  20083ac <pthread_cond_init>              
 2007cf4:	90 12 21 c0 	or  %o0, 0x1c0, %o0                            
  if (result != 0) {                                                  
 2007cf8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2007cfc:	02 80 00 09 	be  2007d20 <rtems_aio_init+0x98>              <== ALWAYS TAKEN
 2007d00:	03 00 80 7e 	sethi  %hi(0x201f800), %g1                     
    pthread_mutex_destroy (&aio_request_queue.mutex);                 
 2007d04:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     <== NOT EXECUTED
 2007d08:	40 00 02 4f 	call  2008644 <pthread_mutex_destroy>          <== NOT EXECUTED
 2007d0c:	90 12 21 bc 	or  %o0, 0x1bc, %o0	! 201f9bc <aio_request_queue><== NOT EXECUTED
    pthread_attr_destroy (&aio_request_queue.attr);                   
 2007d10:	11 00 80 7e 	sethi  %hi(0x201f800), %o0                     <== NOT EXECUTED
 2007d14:	40 00 03 66 	call  2008aac <pthread_attr_destroy>           <== NOT EXECUTED
 2007d18:	90 12 21 c4 	or  %o0, 0x1c4, %o0	! 201f9c4 <aio_request_queue+0x8><== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 2007d1c:	03 00 80 7e 	sethi  %hi(0x201f800), %g1                     <== NOT EXECUTED
 2007d20:	82 10 61 bc 	or  %g1, 0x1bc, %g1	! 201f9bc <aio_request_queue>
 2007d24:	84 00 60 4c 	add  %g1, 0x4c, %g2                            
 2007d28:	c4 20 60 48 	st  %g2, [ %g1 + 0x48 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
 2007d2c:	84 00 60 48 	add  %g1, 0x48, %g2                            
 2007d30:	c4 20 60 50 	st  %g2, [ %g1 + 0x50 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 2007d34:	84 00 60 58 	add  %g1, 0x58, %g2                            
 2007d38:	c4 20 60 54 	st  %g2, [ %g1 + 0x54 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
 2007d3c:	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;                                                  
  head->previous = NULL;                                              
 2007d40:	c0 20 60 4c 	clr  [ %g1 + 0x4c ]                            
  tail->previous = head;                                              
 2007d44:	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;                                                  
  head->previous = NULL;                                              
 2007d48:	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;                               
  aio_request_queue.idle_threads = 0;                                 
  aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;              
 2007d4c:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&aio_request_queue.work_req);         
  rtems_chain_initialize_empty (&aio_request_queue.idle_req);         
                                                                      
  aio_request_queue.active_threads = 0;                               
 2007d50:	c0 20 60 64 	clr  [ %g1 + 0x64 ]                            
  aio_request_queue.idle_threads = 0;                                 
  aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;              
 2007d54:	84 10 a0 0b 	or  %g2, 0xb, %g2                              
                                                                      
  rtems_chain_initialize_empty (&aio_request_queue.work_req);         
  rtems_chain_initialize_empty (&aio_request_queue.idle_req);         
                                                                      
  aio_request_queue.active_threads = 0;                               
  aio_request_queue.idle_threads = 0;                                 
 2007d58:	c0 20 60 68 	clr  [ %g1 + 0x68 ]                            
  aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;              
 2007d5c:	c4 20 60 60 	st  %g2, [ %g1 + 0x60 ]                        
                                                                      
  return result;                                                      
}                                                                     
 2007d60:	81 c7 e0 08 	ret                                            
 2007d64:	81 e8 00 00 	restore                                        
                                                                      

02007c28 <rtems_aio_insert_prio>:
 2007c28:	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 );                            
 2007c2c:	86 02 20 04 	add  %o0, 4, %g3                               
  rtems_chain_node *node;                                             
                                                                      
  AIO_printf ("FD exists \n");                                        
  node = rtems_chain_first (chain);                                   
                                                                      
  if (rtems_chain_is_empty (chain)) {                                 
 2007c30:	80 a0 40 03 	cmp  %g1, %g3                                  
 2007c34:	02 80 00 0e 	be  2007c6c <rtems_aio_insert_prio+0x44>       <== NEVER TAKEN
 2007c38:	84 10 00 09 	mov  %o1, %g2                                  
    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;     
 2007c3c:	c8 00 60 14 	ld  [ %g1 + 0x14 ], %g4                        
                                                                      
    while (req->aiocbp->aio_reqprio > prio &&                         
 2007c40:	da 02 60 14 	ld  [ %o1 + 0x14 ], %o5                        
  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;     
 2007c44:	c8 01 20 18 	ld  [ %g4 + 0x18 ], %g4                        
                                                                      
    while (req->aiocbp->aio_reqprio > prio &&                         
 2007c48:	10 80 00 04 	b  2007c58 <rtems_aio_insert_prio+0x30>        
 2007c4c:	da 03 60 18 	ld  [ %o5 + 0x18 ], %o5                        
           !rtems_chain_is_tail (chain, node)) {                      
      node = rtems_chain_next (node);                                 
      prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;       
 2007c50:	c8 00 60 14 	ld  [ %g1 + 0x14 ], %g4                        <== NOT EXECUTED
 2007c54:	c8 01 20 18 	ld  [ %g4 + 0x18 ], %g4                        <== 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 &&                         
 2007c58:	80 a3 40 04 	cmp  %o5, %g4                                  
 2007c5c:	14 80 00 07 	bg  2007c78 <rtems_aio_insert_prio+0x50>       <== NEVER TAKEN
 2007c60:	80 a0 40 03 	cmp  %g1, %g3                                  
 2007c64:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
 2007c68:	92 10 00 02 	mov  %g2, %o1                                  
 2007c6c:	82 13 c0 00 	mov  %o7, %g1                                  
 2007c70:	40 00 09 de 	call  200a3e8 <_Chain_Insert>                  
 2007c74:	9e 10 40 00 	mov  %g1, %o7                                  
 2007c78:	32 bf ff f6 	bne,a   2007c50 <rtems_aio_insert_prio+0x28>   <== NOT EXECUTED
 2007c7c:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
 2007c80:	10 bf ff fa 	b  2007c68 <rtems_aio_insert_prio+0x40>        <== NOT EXECUTED
 2007c84:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           <== NOT EXECUTED
                                                                      

02007e58 <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) {
 2007e58:	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;                    
 2007e5c:	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 );                            
 2007e60:	82 06 20 04 	add  %i0, 4, %g1                               
  if (rtems_chain_is_empty (chain))                                   
 2007e64:	80 a7 40 01 	cmp  %i5, %g1                                  
 2007e68:	12 80 00 09 	bne  2007e8c <rtems_aio_remove_req+0x34>       
 2007e6c:	b0 10 20 02 	mov  2, %i0                                    
 2007e70:	81 c7 e0 08 	ret                                            
 2007e74:	81 e8 00 00 	restore                                        
  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) {
 2007e78:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
 2007e7c:	32 80 00 05 	bne,a   2007e90 <rtems_aio_remove_req+0x38>    <== NOT EXECUTED
 2007e80:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        <== NOT EXECUTED
    node = rtems_chain_next (node);                                   
    current = (rtems_aio_request *) node;                             
  }                                                                   
                                                                      
  if (rtems_chain_is_tail (chain, node))                              
    return AIO_NOTCANCELED;                                           
 2007e84:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2007e88:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
  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) {
 2007e8c:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 2007e90:	80 a0 80 19 	cmp  %g2, %i1                                  
 2007e94:	32 bf ff f9 	bne,a   2007e78 <rtems_aio_remove_req+0x20>    <== NEVER TAKEN
 2007e98:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
    node = rtems_chain_next (node);                                   
    current = (rtems_aio_request *) node;                             
  }                                                                   
                                                                      
  if (rtems_chain_is_tail (chain, node))                              
 2007e9c:	80 a7 40 01 	cmp  %i5, %g1                                  
 2007ea0:	02 bf ff f4 	be  2007e70 <rtems_aio_remove_req+0x18>        <== NEVER TAKEN
 2007ea4:	b0 10 20 01 	mov  1, %i0                                    
 2007ea8:	40 00 09 37 	call  200a384 <_Chain_Extract>                 
 2007eac:	90 10 00 1d 	mov  %i5, %o0                                  
    return AIO_NOTCANCELED;                                           
  else                                                                
    {                                                                 
      rtems_chain_extract (node);                                     
      current->aiocbp->error_code = ECANCELED;                        
 2007eb0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2007eb4:	84 10 20 8c 	mov  0x8c, %g2                                 
 2007eb8:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
      current->aiocbp->return_value = -1;                             
 2007ebc:	84 10 3f ff 	mov  -1, %g2                                   
      free (current);                                                 
 2007ec0:	90 10 00 1d 	mov  %i5, %o0                                  
    return AIO_NOTCANCELED;                                           
  else                                                                
    {                                                                 
      rtems_chain_extract (node);                                     
      current->aiocbp->error_code = ECANCELED;                        
      current->aiocbp->return_value = -1;                             
 2007ec4:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
      free (current);                                                 
 2007ec8:	7f ff ef 1b 	call  2003b34 <free>                           
 2007ecc:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
                                                                      
  return AIO_CANCELED;                                                
}                                                                     
 2007ed0:	81 c7 e0 08 	ret                                            
 2007ed4:	81 e8 00 00 	restore                                        
                                                                      

0200d18c <rtems_bdbuf_add_to_modified_list_after_access>: } } static void rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd) {
 200d18c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)   
 200d190:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     
 200d194:	ba 17 62 4c 	or  %i5, 0x24c, %i5	! 202164c <bdbuf_cache>    
 200d198:	c2 0f 60 30 	ldub  [ %i5 + 0x30 ], %g1                      
 200d19c:	80 a0 60 00 	cmp  %g1, 0                                    
 200d1a0:	22 80 00 12 	be,a   200d1e8 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== ALWAYS TAKEN
 200d1a4:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
 200d1a8:	c4 07 60 38 	ld  [ %i5 + 0x38 ], %g2                        <== NOT EXECUTED
 200d1ac:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
 200d1b0:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
 200d1b4:	32 80 00 0d 	bne,a   200d1e8 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== NOT EXECUTED
 200d1b8:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
 200d1bc:	7f ff fe 4c 	call  200caec <rtems_bdbuf_unlock_cache>       <== NOT EXECUTED
 200d1c0:	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);
 200d1c4:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
 200d1c8:	7f ff fe 28 	call  200ca68 <rtems_bdbuf_lock>               <== NOT EXECUTED
 200d1cc:	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,                          
 200d1d0:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
 200d1d4:	7f ff fe 3c 	call  200cac4 <rtems_bdbuf_unlock>             <== NOT EXECUTED
 200d1d8:	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 ();                                        
 200d1dc:	7f ff fe 2f 	call  200ca98 <rtems_bdbuf_lock_cache>         <== NOT EXECUTED
 200d1e0:	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                    
 200d1e4:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
 200d1e8:	80 a0 60 05 	cmp  %g1, 5                                    
 200d1ec:	22 80 00 06 	be,a   200d204 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
 200d1f0:	03 00 80 7b 	sethi  %hi(0x201ec00), %g1                     
 200d1f4:	80 a0 60 03 	cmp  %g1, 3                                    
 200d1f8:	12 80 00 06 	bne  200d210 <rtems_bdbuf_add_to_modified_list_after_access+0x84>
 200d1fc:	82 10 20 07 	mov  7, %g1                                    
        || bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)               
    bd->hold_timer = bdbuf_config.swap_block_hold;                    
 200d200:	03 00 80 7b 	sethi  %hi(0x201ec00), %g1                     
 200d204:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1	! 201ec08 <rtems_bdbuf_configuration+0x10>
 200d208:	c2 26 20 2c 	st  %g1, [ %i0 + 0x2c ]                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200d20c:	82 10 20 07 	mov  7, %g1                                    
 200d210:	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;                              
 200d214:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200d218:	82 10 62 4c 	or  %g1, 0x24c, %g1	! 202164c <bdbuf_cache>    
 200d21c:	c4 00 60 54 	ld  [ %g1 + 0x54 ], %g2                        
                                                                      
  the_node->next = tail;                                              
 200d220:	86 00 60 50 	add  %g1, 0x50, %g3                            
  tail->previous = the_node;                                          
 200d224:	f0 20 60 54 	st  %i0, [ %g1 + 0x54 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200d228:	c6 26 00 00 	st  %g3, [ %i0 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 200d22c:	f0 20 80 00 	st  %i0, [ %g2 ]                               
  the_node->previous = old_last;                                      
 200d230:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
    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)                                                    
 200d234:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
 200d238:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d23c:	22 80 00 04 	be,a   200d24c <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
 200d240:	c2 00 60 74 	ld  [ %g1 + 0x74 ], %g1                        
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
 200d244:	7f ff fe be 	call  200cd3c <rtems_bdbuf_wake>               
 200d248:	91 e8 60 64 	restore  %g1, 0x64, %o0                        
  else if (rtems_bdbuf_has_buffer_waiters ())                         
 200d24c:	80 a0 60 00 	cmp  %g1, 0                                    
 200d250:	02 80 00 04 	be  200d260 <rtems_bdbuf_add_to_modified_list_after_access+0xd4>
 200d254:	01 00 00 00 	nop                                            
    rtems_bdbuf_wake_swapper ();                                      
 200d258:	7f ff fe 2b 	call  200cb04 <rtems_bdbuf_wake_swapper>       
 200d25c:	81 e8 00 00 	restore                                        
 200d260:	81 c7 e0 08 	ret                                            
 200d264:	81 e8 00 00 	restore                                        
                                                                      

0200cba0 <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) {
 200cba0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_mode        prev_mode;                                        
                                                                      
  /*                                                                  
   * Indicate we are waiting.                                         
   */                                                                 
  ++waiters->count;                                                   
 200cba4:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 200cba8:	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 ();                      
 200cbac:	7f ff ff e2 	call  200cb34 <rtems_bdbuf_disable_preemption> 
 200cbb0:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  /*                                                                  
   * Unlock the cache, wait, and lock the cache when we return.       
   */                                                                 
  rtems_bdbuf_unlock_cache ();                                        
 200cbb4:	7f ff ff ce 	call  200caec <rtems_bdbuf_unlock_cache>       
 200cbb8:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
 200cbbc:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
 200cbc0:	92 10 20 00 	clr  %o1                                       
 200cbc4:	7f ff ef cd 	call  2008af8 <rtems_semaphore_obtain>         
 200cbc8:	94 10 20 00 	clr  %o2                                       
                                                                      
  if (sc == RTEMS_TIMEOUT)                                            
 200cbcc:	80 a2 20 06 	cmp  %o0, 6                                    
 200cbd0:	12 80 00 04 	bne  200cbe0 <rtems_bdbuf_anonymous_wait+0x40> <== ALWAYS TAKEN
 200cbd4:	80 a2 20 0d 	cmp  %o0, 0xd                                  
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);              
 200cbd8:	10 80 00 04 	b  200cbe8 <rtems_bdbuf_anonymous_wait+0x48>   <== NOT EXECUTED
 200cbdc:	90 10 20 03 	mov  3, %o0                                    <== NOT EXECUTED
                                                                      
  if (sc != RTEMS_UNSATISFIED)                                        
 200cbe0:	02 80 00 04 	be  200cbf0 <rtems_bdbuf_anonymous_wait+0x50>  <== ALWAYS TAKEN
 200cbe4:	90 10 20 02 	mov  2, %o0                                    
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);               
 200cbe8:	7f ff ff 9b 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cbec:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  rtems_bdbuf_lock_cache ();                                          
 200cbf0:	7f ff ff aa 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200cbf4:	01 00 00 00 	nop                                            
                                                                      
  rtems_bdbuf_restore_preemption (prev_mode);                         
 200cbf8:	7f ff ff dc 	call  200cb68 <rtems_bdbuf_restore_preemption> 
 200cbfc:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  --waiters->count;                                                   
 200cc00:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 200cc04:	82 00 7f ff 	add  %g1, -1, %g1                              
 200cc08:	c2 26 00 00 	st  %g1, [ %i0 ]                               
 200cc0c:	81 c7 e0 08 	ret                                            
 200cc10:	81 e8 00 00 	restore                                        
                                                                      

0200cd74 <rtems_bdbuf_create_task.constprop.10>: return NULL; } static rtems_status_code rtems_bdbuf_create_task(
 200cd74:	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 ?                  
 200cd78:	03 00 80 7b 	sethi  %hi(0x201ec00), %g1                     
 200cd7c:	d4 00 60 14 	ld  [ %g1 + 0x14 ], %o2	! 201ec14 <rtems_bdbuf_configuration+0x1c>
    bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
 200cd80:	80 a2 a0 00 	cmp  %o2, 0                                    
 200cd84:	12 80 00 03 	bne  200cd90 <rtems_bdbuf_create_task.constprop.10+0x1c><== ALWAYS TAKEN
 200cd88:	92 10 00 19 	mov  %i1, %o1                                  
 200cd8c:	15 00 00 04 	sethi  %hi(0x1000), %o2                        <== NOT EXECUTED
                                                                      
  priority = priority != 0 ? priority : default_priority;             
 200cd90:	80 a2 60 00 	cmp  %o1, 0                                    
 200cd94:	22 80 00 02 	be,a   200cd9c <rtems_bdbuf_create_task.constprop.10+0x28><== NEVER TAKEN
 200cd98:	92 10 20 0f 	mov  0xf, %o1                                  <== NOT EXECUTED
                                                                      
  sc = rtems_task_create (name,                                       
 200cd9c:	90 10 00 18 	mov  %i0, %o0                                  
 200cda0:	96 10 24 00 	mov  0x400, %o3                                
 200cda4:	98 10 20 00 	clr  %o4                                       
 200cda8:	7f ff ef df 	call  2008d24 <rtems_task_create>              
 200cdac:	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)                                         
 200cdb0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200cdb4:	12 80 00 05 	bne  200cdc8 <rtems_bdbuf_create_task.constprop.10+0x54><== NEVER TAKEN
 200cdb8:	b2 10 00 1a 	mov  %i2, %i1                                  
    sc = rtems_task_start (*id, entry, arg);                          
 200cdbc:	f0 07 00 00 	ld  [ %i4 ], %i0                               
 200cdc0:	7f ff f0 66 	call  2008f58 <rtems_task_start>               
 200cdc4:	95 e8 00 1b 	restore  %g0, %i3, %o2                         
                                                                      
  return sc;                                                          
}                                                                     
 200cdc8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200cdcc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200cb34 <rtems_bdbuf_disable_preemption>: --bd->group->users; } static rtems_mode rtems_bdbuf_disable_preemption (void) {
 200cb34:	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);
 200cb38:	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;                                           
 200cb3c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
 200cb40:	92 10 21 00 	mov  0x100, %o1                                
 200cb44:	40 00 11 6e 	call  20110fc <rtems_task_mode>                
 200cb48:	94 07 bf fc 	add  %fp, -4, %o2                              
  if (sc != RTEMS_SUCCESSFUL)                                         
 200cb4c:	80 a2 20 00 	cmp  %o0, 0                                    
 200cb50:	22 80 00 04 	be,a   200cb60 <rtems_bdbuf_disable_preemption+0x2c><== ALWAYS TAKEN
 200cb54:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);                
 200cb58:	7f ff ff bf 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cb5c:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
                                                                      
  return prev_mode;                                                   
}                                                                     
 200cb60:	81 c7 e0 08 	ret                                            
 200cb64:	81 e8 00 00 	restore                                        
                                                                      

0200e0b4 <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) {
 200e0b4:	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) +                  
 200e0b8:	83 2e a0 04 	sll  %i2, 4, %g1                               
 200e0bc:	82 00 60 20 	add  %g1, 0x20, %g1                            
 200e0c0:	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;                              
 200e0c4:	03 00 80 36 	sethi  %hi(0x200d800), %g1                     
 200e0c8:	82 10 61 e0 	or  %g1, 0x1e0, %g1	! 200d9e0 <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) +                  
 200e0cc:	ba 03 a0 60 	add  %sp, 0x60, %i5                            
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;                          
 200e0d0:	f6 06 60 18 	ld  [ %i1 + 0x18 ], %i3                        
  uint32_t media_blocks_per_block = dd->media_blocks_per_block;       
  uint32_t block_size = dd->block_size;                               
 200e0d4:	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;       
 200e0d8:	e2 06 20 2c 	ld  [ %i0 + 0x2c ], %l1                        
                                                                      
  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;                              
 200e0dc:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
  req->io_task = rtems_task_self ();                                  
 200e0e0:	40 00 0c 65 	call  2011274 <rtems_task_self>                
 200e0e4:	c0 27 40 00 	clr  [ %i5 ]                                   
  req->bufnum = 0;                                                    
 200e0e8:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
  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 ();                                  
 200e0ec:	d0 27 60 14 	st  %o0, [ %i5 + 0x14 ]                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200e0f0:	82 10 20 09 	mov  9, %g1                                    
 200e0f4:	c2 26 60 20 	st  %g1, [ %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;                                          
 200e0f8:	f2 27 60 24 	st  %i1, [ %i5 + 0x24 ]                        
  req->bufs [0].block  = media_block;                                 
  req->bufs [0].length = block_size;                                  
  req->bufs [0].buffer = bd->buffer;                                  
 200e0fc:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
  req->bufnum = 0;                                                    
                                                                      
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);             
                                                                      
  req->bufs [0].user   = bd;                                          
  req->bufs [0].block  = media_block;                                 
 200e100:	f6 27 60 18 	st  %i3, [ %i5 + 0x18 ]                        
  req->bufs [0].length = block_size;                                  
 200e104:	e0 27 60 1c 	st  %l0, [ %i5 + 0x1c ]                        
  req->bufs [0].buffer = bd->buffer;                                  
 200e108:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
 200e10c:	b8 10 00 1d 	mov  %i5, %i4                                  
{                                                                     
  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;                                        
 200e110:	b2 10 20 01 	mov  1, %i1                                    
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  while (transfer_index < transfer_count)                             
 200e114:	10 80 00 16 	b  200e16c <rtems_bdbuf_execute_read_request+0xb8>
 200e118:	a4 10 20 09 	mov  9, %l2                                    
  {                                                                   
    media_block += media_blocks_per_block;                            
                                                                      
    bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);     
 200e11c:	90 10 00 18 	mov  %i0, %o0                                  
 200e120:	92 10 00 1b 	mov  %i3, %o1                                  
 200e124:	7f ff fd 4d 	call  200d658 <rtems_bdbuf_get_buffer_for_read_ahead>
 200e128:	b8 07 20 10 	add  %i4, 0x10, %i4                            
                                                                      
    if (bd == NULL)                                                   
 200e12c:	80 a2 20 00 	cmp  %o0, 0                                    
 200e130:	32 80 00 09 	bne,a   200e154 <rtems_bdbuf_execute_read_request+0xa0><== ALWAYS TAKEN
 200e134:	e4 22 20 20 	st  %l2, [ %o0 + 0x20 ]                        
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
  }                                                                   
                                                                      
  req->bufnum = transfer_index;                                       
 200e138:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        <== NOT EXECUTED
                                                                      
  return rtems_bdbuf_execute_transfer_request (dd, req, true);        
 200e13c:	90 10 00 18 	mov  %i0, %o0                                  
 200e140:	92 10 00 1d 	mov  %i5, %o1                                  
 200e144:	7f ff fe 2d 	call  200d9f8 <rtems_bdbuf_execute_transfer_request>
 200e148:	94 10 20 01 	mov  1, %o2                                    
 200e14c:	81 c7 e0 08 	ret                                            
 200e150:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    if (bd == NULL)                                                   
      break;                                                          
                                                                      
    rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);           
                                                                      
    req->bufs [transfer_index].user   = bd;                           
 200e154:	d0 27 20 24 	st  %o0, [ %i4 + 0x24 ]                        
    req->bufs [transfer_index].block  = media_block;                  
 200e158:	f6 27 20 18 	st  %i3, [ %i4 + 0x18 ]                        
    req->bufs [transfer_index].length = block_size;                   
 200e15c:	e0 27 20 1c 	st  %l0, [ %i4 + 0x1c ]                        
    req->bufs [transfer_index].buffer = bd->buffer;                   
 200e160:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
                                                                      
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
 200e164:	b2 06 60 01 	inc  %i1                                       
    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;                   
 200e168:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
  req->bufs [0].buffer = bd->buffer;                                  
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_users ("read", bd);                              
                                                                      
  while (transfer_index < transfer_count)                             
 200e16c:	80 a6 40 1a 	cmp  %i1, %i2                                  
 200e170:	2a bf ff eb 	bcs,a   200e11c <rtems_bdbuf_execute_read_request+0x68>
 200e174:	b6 06 c0 11 	add  %i3, %l1, %i3                             
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
  }                                                                   
                                                                      
  req->bufnum = transfer_index;                                       
 200e178:	10 bf ff f1 	b  200e13c <rtems_bdbuf_execute_read_request+0x88>
 200e17c:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        
                                                                      

0200ca54 <rtems_bdbuf_fatal>: #define RTEMS_BDBUF_AVL_MAX_HEIGHT (32) #endif static void rtems_bdbuf_fatal (rtems_fatal_code error) {
 200ca54:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);                      
 200ca58:	90 10 20 03 	mov  3, %o0                                    <== NOT EXECUTED
 200ca5c:	7f ff f1 e6 	call  20091f4 <rtems_fatal>                    <== NOT EXECUTED
 200ca60:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
                                                                      

0200cab0 <rtems_bdbuf_fatal_with_state>: } static void rtems_bdbuf_fatal_with_state (rtems_bdbuf_buf_state state, rtems_bdbuf_fatal_code error) {
 200cab0:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_bdbuf_fatal ((((uint32_t) state) << 16) | error);             
 200cab4:	b1 2e 20 10 	sll  %i0, 0x10, %i0                            <== NOT EXECUTED
 200cab8:	7f ff ff e7 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cabc:	90 16 40 18 	or  %i1, %i0, %o0                              <== NOT EXECUTED
                                                                      

0200e798 <rtems_bdbuf_get>: rtems_status_code rtems_bdbuf_get (rtems_disk_device *dd, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
 200e798:	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 ();                                          
 200e79c:	7f ff f8 bf 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200e7a0:	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)                                        
 200e7a4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
rtems_bdbuf_get (rtems_disk_device   *dd,                             
                 rtems_blkdev_bnum    block,                          
                 rtems_bdbuf_buffer **bd_ptr)                         
{                                                                     
  rtems_status_code   sc = RTEMS_SUCCESSFUL;                          
  rtems_bdbuf_buffer *bd = NULL;                                      
 200e7a8:	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)                                        
 200e7ac:	80 a6 40 01 	cmp  %i1, %g1                                  
 200e7b0:	1a 80 00 26 	bcc  200e848 <rtems_bdbuf_get+0xb0>            <== NEVER TAKEN
 200e7b4:	b0 10 20 04 	mov  4, %i0                                    
}                                                                     
                                                                      
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)                            
 200e7b8:	d2 07 60 30 	ld  [ %i5 + 0x30 ], %o1                        
 200e7bc:	80 a2 60 00 	cmp  %o1, 0                                    
 200e7c0:	26 80 00 04 	bl,a   200e7d0 <rtems_bdbuf_get+0x38>          <== NEVER TAKEN
 200e7c4:	d6 07 60 24 	ld  [ %i5 + 0x24 ], %o3                        <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
 200e7c8:	10 80 00 09 	b  200e7ec <rtems_bdbuf_get+0x54>              
 200e7cc:	93 2e 40 09 	sll  %i1, %o1, %o1                             
    /*                                                                
     * 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); 
 200e7d0:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 200e7d4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 200e7d8:	40 00 39 43 	call  201cce4 <__muldi3>                       <== NOT EXECUTED
 200e7dc:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 200e7e0:	d6 07 60 20 	ld  [ %i5 + 0x20 ], %o3                        <== NOT EXECUTED
 200e7e4:	40 00 3b 51 	call  201d528 <__udivdi3>                      <== NOT EXECUTED
 200e7e8:	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;
 200e7ec:	c2 07 60 18 	ld  [ %i5 + 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);         
 200e7f0:	90 10 00 1d 	mov  %i5, %o0                                  
 200e7f4:	7f ff fb ac 	call  200d6a4 <rtems_bdbuf_get_buffer_for_access>
 200e7f8:	92 02 40 01 	add  %o1, %g1, %o1                             
 200e7fc:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    switch (bd->state)                                                
 200e800:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
 200e804:	80 a2 20 02 	cmp  %o0, 2                                    
 200e808:	02 80 00 08 	be  200e828 <rtems_bdbuf_get+0x90>             
 200e80c:	80 a2 20 07 	cmp  %o0, 7                                    
 200e810:	02 80 00 0a 	be  200e838 <rtems_bdbuf_get+0xa0>             
 200e814:	80 a2 20 01 	cmp  %o0, 1                                    
 200e818:	12 80 00 0a 	bne  200e840 <rtems_bdbuf_get+0xa8>            <== NEVER TAKEN
 200e81c:	82 10 20 05 	mov  5, %g1                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200e820:	10 80 00 04 	b  200e830 <rtems_bdbuf_get+0x98>              
 200e824:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
 200e828:	82 10 20 03 	mov  3, %g1                                    
 200e82c:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
 200e830:	10 80 00 06 	b  200e848 <rtems_bdbuf_get+0xb0>              
 200e834:	b0 10 20 00 	clr  %i0                                       
 200e838:	10 bf ff fd 	b  200e82c <rtems_bdbuf_get+0x94>              
 200e83c:	82 10 20 04 	mov  4, %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);
 200e840:	7f ff f8 9c 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200e844:	92 10 20 0f 	mov  0xf, %o1                                  <== NOT EXECUTED
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200e848:	7f ff f8 a9 	call  200caec <rtems_bdbuf_unlock_cache>       
 200e84c:	01 00 00 00 	nop                                            
                                                                      
  *bd_ptr = bd;                                                       
 200e850:	f8 26 80 00 	st  %i4, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
 200e854:	81 c7 e0 08 	ret                                            
 200e858:	81 e8 00 00 	restore                                        
                                                                      

0200d6a4 <rtems_bdbuf_get_buffer_for_access>: static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd, rtems_blkdev_bnum block) {
 200d6a4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
 200d6a8:	39 00 80 85 	sethi  %hi(0x2021400), %i4                     
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d6ac:	35 00 80 32 	sethi  %hi(0x200c800), %i2                     
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
 200d6b0:	b8 17 22 4c 	or  %i4, 0x24c, %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);         
 200d6b4:	a0 07 20 6c 	add  %i4, 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);           
 200d6b8:	a2 07 20 64 	add  %i4, 0x64, %l1                            
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200d6bc:	a4 07 20 5c 	add  %i4, 0x5c, %l2                            
      {                                                               
        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);             
 200d6c0:	b6 07 20 74 	add  %i4, 0x74, %i3                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
 200d6c4:	a6 07 20 50 	add  %i4, 0x50, %l3                            
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
 200d6c8:	d0 07 20 3c 	ld  [ %i4 + 0x3c ], %o0                        
 200d6cc:	92 10 00 18 	mov  %i0, %o1                                  
 200d6d0:	7f ff fd 82 	call  200ccd8 <rtems_bdbuf_avl_search.isra.0>  
 200d6d4:	94 10 00 19 	mov  %i1, %o2                                  
                                                                      
    if (bd != NULL)                                                   
 200d6d8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200d6dc:	02 80 00 2f 	be  200d798 <rtems_bdbuf_get_buffer_for_access+0xf4>
 200d6e0:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
      if (bd->group->bds_per_group != dd->bds_per_group)              
 200d6e4:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 200d6e8:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 200d6ec:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
 200d6f0:	80 a0 80 01 	cmp  %g2, %g1                                  
 200d6f4:	02 80 00 35 	be  200d7c8 <rtems_bdbuf_get_buffer_for_access+0x124>
 200d6f8:	a8 10 20 08 	mov  8, %l4                                    
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d6fc:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
 200d700:	80 a2 20 0a 	cmp  %o0, 0xa                                  
 200d704:	18 80 00 4f 	bgu  200d840 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
 200d708:	92 10 20 14 	mov  0x14, %o1                                 
 200d70c:	82 16 a1 ac 	or  %i2, 0x1ac, %g1                            
 200d710:	91 2a 20 02 	sll  %o0, 2, %o0                               
 200d714:	c2 00 40 08 	ld  [ %g1 + %o0 ], %g1                         
 200d718:	81 c0 40 00 	jmp  %g1                                       
 200d71c:	01 00 00 00 	nop                                            
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200d720:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 200d724:	c4 07 40 00 	ld  [ %i5 ], %g2                               <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200d728:	e8 27 60 20 	st  %l4, [ %i5 + 0x20 ]                        <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
 200d72c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
 200d730:	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;                              
 200d734:	c2 07 20 60 	ld  [ %i4 + 0x60 ], %g1                        <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
 200d738:	e4 27 40 00 	st  %l2, [ %i5 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
 200d73c:	fa 27 20 60 	st  %i5, [ %i4 + 0x60 ]                        <== NOT EXECUTED
  old_last->next = the_node;                                          
 200d740:	fa 20 40 00 	st  %i5, [ %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 ();                                        
 200d744:	7f ff fc f0 	call  200cb04 <rtems_bdbuf_wake_swapper>       <== NOT EXECUTED
 200d748:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           <== NOT EXECUTED
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d74c:	10 bf ff ed 	b  200d700 <rtems_bdbuf_get_buffer_for_access+0x5c><== NOT EXECUTED
 200d750:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        <== NOT EXECUTED
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        rtems_bdbuf_request_sync_for_modified_buffer (bd);            
        break;                                                        
      case RTEMS_BDBUF_STATE_CACHED:                                  
      case RTEMS_BDBUF_STATE_EMPTY:                                   
        if (bd->waiters == 0)                                         
 200d754:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 200d758:	80 a0 60 00 	cmp  %g1, 0                                    
 200d75c:	02 80 00 3b 	be  200d848 <rtems_bdbuf_get_buffer_for_access+0x1a4><== NEVER TAKEN
 200d760:	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);   
 200d764:	7f ff fd 0f 	call  200cba0 <rtems_bdbuf_anonymous_wait>     
 200d768:	90 10 00 1b 	mov  %i3, %o0                                  
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
 200d76c:	10 bf ff d8 	b  200d6cc <rtems_bdbuf_get_buffer_for_access+0x28>
 200d770:	d0 07 20 3c 	ld  [ %i4 + 0x3c ], %o0                        
        }                                                             
      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);           
 200d774:	90 10 00 1d 	mov  %i5, %o0                                  
 200d778:	10 80 00 04 	b  200d788 <rtems_bdbuf_get_buffer_for_access+0xe4>
 200d77c:	92 10 00 11 	mov  %l1, %o1                                  
        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);         
 200d780:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 200d784:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 200d788:	7f ff fd 23 	call  200cc14 <rtems_bdbuf_wait>               
 200d78c:	01 00 00 00 	nop                                            
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d790:	10 bf ff dc 	b  200d700 <rtems_bdbuf_get_buffer_for_access+0x5c>
 200d794:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
        bd = NULL;                                                    
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);          
 200d798:	7f ff fe c7 	call  200d2b4 <rtems_bdbuf_get_buffer_from_lru_list>
 200d79c:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
      if (bd == NULL)                                                 
 200d7a0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200d7a4:	32 80 00 0a 	bne,a   200d7cc <rtems_bdbuf_get_buffer_for_access+0x128>
 200d7a8:	39 00 80 85 	sethi  %hi(0x2021400), %i4                     
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
 200d7ac:	c2 07 20 4c 	ld  [ %i4 + 0x4c ], %g1	! 202144c <lc_message_charset+0x1c>
 200d7b0:	80 a0 40 13 	cmp  %g1, %l3                                  
 200d7b4:	02 bf ff ec 	be  200d764 <rtems_bdbuf_get_buffer_for_access+0xc0>
 200d7b8:	01 00 00 00 	nop                                            
    rtems_bdbuf_wake_swapper ();                                      
 200d7bc:	7f ff fc d2 	call  200cb04 <rtems_bdbuf_wake_swapper>       
 200d7c0:	01 00 00 00 	nop                                            
 200d7c4:	30 bf ff e8 	b,a   200d764 <rtems_bdbuf_get_buffer_for_access+0xc0>
        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);         
 200d7c8:	39 00 80 85 	sethi  %hi(0x2021400), %i4                     
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d7cc:	37 00 80 32 	sethi  %hi(0x200c800), %i3                     
        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);         
 200d7d0:	b8 17 22 b8 	or  %i4, 0x2b8, %i4                            
        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);           
 200d7d4:	b4 07 3f f8 	add  %i4, -8, %i2                              
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d7d8:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
 200d7dc:	82 02 3f ff 	add  %o0, -1, %g1                              
 200d7e0:	80 a0 60 09 	cmp  %g1, 9                                    
 200d7e4:	18 80 00 17 	bgu  200d840 <rtems_bdbuf_get_buffer_for_access+0x19c><== NEVER TAKEN
 200d7e8:	92 10 20 13 	mov  0x13, %o1                                 
 200d7ec:	84 16 e1 84 	or  %i3, 0x184, %g2                            
 200d7f0:	83 28 60 02 	sll  %g1, 2, %g1                               
 200d7f4:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 200d7f8:	81 c0 40 00 	jmp  %g1                                       
 200d7fc:	01 00 00 00 	nop                                            
    {                                                                 
      case RTEMS_BDBUF_STATE_MODIFIED:                                
        rtems_bdbuf_group_release (bd);                               
 200d800:	7f ff fc 90 	call  200ca40 <rtems_bdbuf_group_release>      
 200d804:	90 10 00 1d 	mov  %i5, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 200d808:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
 200d80c:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  next->previous = previous;                                          
 200d810:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 200d814:	10 80 00 15 	b  200d868 <rtems_bdbuf_get_buffer_for_access+0x1c4>
 200d818:	c4 20 40 00 	st  %g2, [ %g1 ]                               
        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);           
 200d81c:	90 10 00 1d 	mov  %i5, %o0                                  
 200d820:	10 80 00 04 	b  200d830 <rtems_bdbuf_get_buffer_for_access+0x18c>
 200d824:	92 10 00 1a 	mov  %i2, %o1                                  
        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);         
 200d828:	90 10 00 1d 	mov  %i5, %o0                                  
 200d82c:	92 10 00 1c 	mov  %i4, %o1                                  
 200d830:	7f ff fc f9 	call  200cc14 <rtems_bdbuf_wait>               
 200d834:	01 00 00 00 	nop                                            
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200d838:	10 bf ff e9 	b  200d7dc <rtems_bdbuf_get_buffer_for_access+0x138>
 200d83c:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %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_7);
 200d840:	7f ff fc 9c 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200d844:	01 00 00 00 	nop                                            <== NOT EXECUTED
    {                                                                 
      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);             
 200d848:	7f ff fe 88 	call  200d268 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
 200d84c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
          rtems_bdbuf_make_free_and_add_to_lru_list (bd);             
 200d850:	7f ff fe 46 	call  200d168 <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
 200d854:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
          rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);             
 200d858:	7f ff fd 39 	call  200cd3c <rtems_bdbuf_wake>               <== NOT EXECUTED
 200d85c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
 200d860:	10 bf ff 9b 	b  200d6cc <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
 200d864:	d0 07 20 3c 	ld  [ %i4 + 0x3c ], %o0                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
  while (bd == NULL);                                                 
                                                                      
  rtems_bdbuf_wait_for_access (bd);                                   
  rtems_bdbuf_group_obtain (bd);                                      
 200d868:	90 10 00 1d 	mov  %i5, %o0                                  
 200d86c:	7f ff fc 70 	call  200ca2c <rtems_bdbuf_group_obtain>       
 200d870:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return bd;                                                          
}                                                                     
 200d874:	81 c7 e0 08 	ret                                            
 200d878:	81 e8 00 00 	restore                                        
                                                                      

0200d658 <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) {
 200d658:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);         
 200d65c:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200d660:	d0 00 62 88 	ld  [ %g1 + 0x288 ], %o0	! 2021688 <bdbuf_cache+0x3c>
 200d664:	92 10 00 18 	mov  %i0, %o1                                  
 200d668:	94 10 00 19 	mov  %i1, %o2                                  
 200d66c:	7f ff fd 9b 	call  200ccd8 <rtems_bdbuf_avl_search.isra.0>  
 200d670:	ba 10 20 00 	clr  %i5                                       
                                                                      
  if (bd == NULL)                                                     
 200d674:	80 a2 20 00 	cmp  %o0, 0                                    
 200d678:	12 80 00 09 	bne  200d69c <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
 200d67c:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);            
 200d680:	7f ff ff 0d 	call  200d2b4 <rtems_bdbuf_get_buffer_from_lru_list>
 200d684:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    if (bd != NULL)                                                   
 200d688:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200d68c:	02 80 00 04 	be  200d69c <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
 200d690:	01 00 00 00 	nop                                            
      rtems_bdbuf_group_obtain (bd);                                  
 200d694:	7f ff fc e6 	call  200ca2c <rtems_bdbuf_group_obtain>       
 200d698:	01 00 00 00 	nop                                            
     * thus no need for a read ahead.                                 
     */                                                               
    bd = NULL;                                                        
                                                                      
  return bd;                                                          
}                                                                     
 200d69c:	81 c7 e0 08 	ret                                            
 200d6a0:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

0200d2b4 <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) {
 200d2b4:	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;                              
 200d2b8:	25 00 80 85 	sethi  %hi(0x2021400), %l2                     
 200d2bc:	90 14 a2 4c 	or  %l2, 0x24c, %o0	! 202164c <bdbuf_cache>    
 200d2c0:	f8 02 20 40 	ld  [ %o0 + 0x40 ], %i4                        
  rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);      
                                                                      
  while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))               
 200d2c4:	a2 02 20 44 	add  %o0, 0x44, %l1                            
 200d2c8:	10 80 00 de 	b  200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
 200d2cc:	a6 02 20 74 	add  %o0, 0x74, %l3                            
              bd->group->bds_per_group, dd->bds_per_group);           
                                                                      
    /*                                                                
     * If nobody waits for this BD, we may recycle it.                
     */                                                               
    if (bd->waiters == 0)                                             
 200d2d0:	80 a0 60 00 	cmp  %g1, 0                                    
 200d2d4:	32 80 00 db 	bne,a   200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
 200d2d8:	f8 07 00 00 	ld  [ %i4 ], %i4                               
    {                                                                 
      if (bd->group->bds_per_group == dd->bds_per_group)              
 200d2dc:	fa 07 20 28 	ld  [ %i4 + 0x28 ], %i5                        
 200d2e0:	f6 06 20 34 	ld  [ %i0 + 0x34 ], %i3                        
 200d2e4:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
 200d2e8:	80 a2 40 1b 	cmp  %o1, %i3                                  
 200d2ec:	32 80 00 06 	bne,a   200d304 <rtems_bdbuf_get_buffer_from_lru_list+0x50>
 200d2f0:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
      {                                                               
        rtems_bdbuf_remove_from_tree_and_lru_list (bd);               
 200d2f4:	7f ff ff dd 	call  200d268 <rtems_bdbuf_remove_from_tree_and_lru_list>
 200d2f8:	90 10 00 1c 	mov  %i4, %o0                                  
 200d2fc:	10 80 00 30 	b  200d3bc <rtems_bdbuf_get_buffer_from_lru_list+0x108>
 200d300:	84 10 00 1c 	mov  %i4, %g2                                  
                                                                      
        empty_bd = bd;                                                
      }                                                               
      else if (bd->group->users == 0)                                 
 200d304:	80 a0 60 00 	cmp  %g1, 0                                    
 200d308:	32 80 00 ce 	bne,a   200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
 200d30c:	f8 07 00 00 	ld  [ %i4 ], %i4                               
  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; 
 200d310:	d0 04 7f dc 	ld  [ %l1 + -36 ], %o0                         
 200d314:	40 00 3d 1c 	call  201c784 <.udiv>                          
 200d318:	f4 07 60 10 	ld  [ %i5 + 0x10 ], %i2                        
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
 200d31c:	a0 10 20 00 	clr  %l0                                       
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
 200d320:	83 2a 20 03 	sll  %o0, 3, %g1                               
 200d324:	91 2a 20 06 	sll  %o0, 6, %o0                               
 200d328:	10 80 00 05 	b  200d33c <rtems_bdbuf_get_buffer_from_lru_list+0x88>
 200d32c:	a8 22 00 01 	sub  %o0, %g1, %l4                             
    rtems_bdbuf_remove_from_tree_and_lru_list (bd);                   
 200d330:	7f ff ff ce 	call  200d268 <rtems_bdbuf_remove_from_tree_and_lru_list>
 200d334:	a0 04 20 01 	inc  %l0                                       
                                                                      
  bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group; 
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
 200d338:	b4 06 80 14 	add  %i2, %l4, %i2                             
            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;                                      
 200d33c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 200d340:	80 a4 00 01 	cmp  %l0, %g1                                  
 200d344:	0a bf ff fb 	bcs  200d330 <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
 200d348:	90 10 00 1a 	mov  %i2, %o0                                  
       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;                           
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
 200d34c:	82 14 a2 4c 	or  %l2, 0x24c, %g1                            
 200d350:	d0 00 60 20 	ld  [ %g1 + 0x20 ], %o0                        
  for (b = 0, bd = group->bdbuf;                                      
       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;                           
 200d354:	f6 27 60 08 	st  %i3, [ %i5 + 8 ]                           
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
 200d358:	40 00 3d 0b 	call  201c784 <.udiv>                          
 200d35c:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
  for (b = 1, bd = group->bdbuf + bufs_per_bd;                        
 200d360:	f4 07 60 10 	ld  [ %i5 + 0x10 ], %i2                        
 200d364:	83 2a 20 03 	sll  %o0, 3, %g1                               
 200d368:	a1 2a 20 06 	sll  %o0, 6, %l0                               
 200d36c:	b6 10 20 01 	mov  1, %i3                                    
 200d370:	a0 24 00 01 	sub  %l0, %g1, %l0                             
 200d374:	10 80 00 05 	b  200d388 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
 200d378:	b4 06 80 10 	add  %i2, %l0, %i2                             
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_make_free_and_add_to_lru_list (bd);                   
 200d37c:	7f ff ff 7b 	call  200d168 <rtems_bdbuf_make_free_and_add_to_lru_list>
 200d380:	b6 06 e0 01 	inc  %i3                                       
  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)                                        
 200d384:	b4 06 80 10 	add  %i2, %l0, %i2                             
    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;                        
 200d388:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 200d38c:	80 a6 c0 01 	cmp  %i3, %g1                                  
 200d390:	0a bf ff fb 	bcs  200d37c <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
 200d394:	90 10 00 1a 	mov  %i2, %o0                                  
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
    rtems_bdbuf_make_free_and_add_to_lru_list (bd);                   
                                                                      
  if (b > 1)                                                          
 200d398:	80 a6 e0 01 	cmp  %i3, 1                                    
 200d39c:	28 80 00 05 	bleu,a   200d3b0 <rtems_bdbuf_get_buffer_from_lru_list+0xfc>
 200d3a0:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
 200d3a4:	7f ff fe 66 	call  200cd3c <rtems_bdbuf_wake>               
 200d3a8:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
  return group->bdbuf;                                                
 200d3ac:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
      }                                                               
      else if (bd->group->users == 0)                                 
        empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
    }                                                                 
                                                                      
    if (empty_bd != NULL)                                             
 200d3b0:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d3b4:	22 80 00 a3 	be,a   200d640 <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
 200d3b8:	f8 07 00 00 	ld  [ %i4 ], %i4                               <== NOT EXECUTED
static void                                                           
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,               
                                rtems_disk_device  *dd,               
                                rtems_blkdev_bnum   block)            
{                                                                     
  bd->dd        = dd ;                                                
 200d3bc:	f0 20 a0 14 	st  %i0, [ %g2 + 0x14 ]                        
  bd->block     = block;                                              
  bd->avl.left  = NULL;                                               
 200d3c0:	c0 20 a0 08 	clr  [ %g2 + 8 ]                               
  bd->avl.right = NULL;                                               
 200d3c4:	c0 20 a0 0c 	clr  [ %g2 + 0xc ]                             
                       rtems_bdbuf_buffer*  node)                     
{                                                                     
  const rtems_disk_device *dd = node->dd;                             
  rtems_blkdev_bnum block = node->block;                              
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
 200d3c8:	07 00 80 85 	sethi  %hi(0x2021400), %g3                     
 200d3cc:	86 10 e2 4c 	or  %g3, 0x24c, %g3	! 202164c <bdbuf_cache>    
 200d3d0:	c2 00 e0 3c 	ld  [ %g3 + 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;                                              
 200d3d4:	f2 20 a0 18 	st  %i1, [ %g2 + 0x18 ]                        
  bd->avl.left  = NULL;                                               
  bd->avl.right = NULL;                                               
  bd->waiters   = 0;                                                  
 200d3d8:	c0 20 a0 24 	clr  [ %g2 + 0x24 ]                            
  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;                          
 200d3dc:	ba 07 bf 80 	add  %fp, -128, %i5                            
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
 200d3e0:	b8 10 3f ff 	mov  -1, %i4                                   
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
 200d3e4:	80 a0 60 00 	cmp  %g1, 0                                    
 200d3e8:	12 80 00 1d 	bne  200d45c <rtems_bdbuf_get_buffer_from_lru_list+0x1a8>
 200d3ec:	b6 10 20 01 	mov  1, %i3                                    
  {                                                                   
    *root = node;                                                     
 200d3f0:	c4 20 e0 3c 	st  %g2, [ %g3 + 0x3c ]                        
    node->avl.left = NULL;                                            
 200d3f4:	c0 20 a0 08 	clr  [ %g2 + 8 ]                               
    node->avl.right = NULL;                                           
 200d3f8:	c0 20 a0 0c 	clr  [ %g2 + 0xc ]                             
    node->avl.bal = 0;                                                
 200d3fc:	10 80 00 8e 	b  200d634 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
 200d400:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
 200d404:	32 80 00 0f 	bne,a   200d440 <rtems_bdbuf_get_buffer_from_lru_list+0x18c><== NEVER TAKEN
 200d408:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           <== NOT EXECUTED
 200d40c:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
 200d410:	80 a0 c0 19 	cmp  %g3, %i1                                  
 200d414:	1a 80 00 08 	bcc  200d434 <rtems_bdbuf_get_buffer_from_lru_list+0x180>
 200d418:	01 00 00 00 	nop                                            
    {                                                                 
      p->avl.cache = 1;                                               
      q = p->avl.right;                                               
 200d41c:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
      if (q == NULL)                                                  
 200d420:	80 a0 e0 00 	cmp  %g3, 0                                    
 200d424:	12 80 00 0c 	bne  200d454 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
 200d428:	f6 28 60 10 	stb  %i3, [ %g1 + 0x10 ]                       
      {                                                               
        q = node;                                                     
        p->avl.right = q = node;                                      
 200d42c:	10 80 00 12 	b  200d474 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
 200d430:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
 200d434:	02 80 00 7e 	be  200d62c <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
 200d438:	01 00 00 00 	nop                                            
    {                                                                 
      p->avl.cache = -1;                                              
      q = p->avl.left;                                                
 200d43c:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
      if (q == NULL)                                                  
 200d440:	80 a0 e0 00 	cmp  %g3, 0                                    
 200d444:	12 80 00 04 	bne  200d454 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
 200d448:	f8 28 60 10 	stb  %i4, [ %g1 + 0x10 ]                       
      {                                                               
        q = node;                                                     
        p->avl.left = q;                                              
 200d44c:	10 80 00 0a 	b  200d474 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
 200d450:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  rtems_bdbuf_buffer*  buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];         
  rtems_bdbuf_buffer** buf_prev = buf_stack;                          
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
 200d454:	ba 10 00 04 	mov  %g4, %i5                                  
 200d458:	82 10 00 03 	mov  %g3, %g1                                  
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
 200d45c:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
    return 0;                                                         
  }                                                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
 200d460:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
 200d464:	80 a0 c0 18 	cmp  %g3, %i0                                  
 200d468:	0a bf ff ed 	bcs  200d41c <rtems_bdbuf_get_buffer_from_lru_list+0x168><== NEVER TAKEN
 200d46c:	88 07 60 04 	add  %i5, 4, %g4                               
 200d470:	30 bf ff e5 	b,a   200d404 <rtems_bdbuf_get_buffer_from_lru_list+0x150>
    }                                                                 
                                                                      
    p = q;                                                            
  }                                                                   
                                                                      
  q->avl.left = q->avl.right = NULL;                                  
 200d474:	c0 20 a0 0c 	clr  [ %g2 + 0xc ]                             
 200d478:	c0 20 a0 08 	clr  [ %g2 + 8 ]                               
  q->avl.bal = 0;                                                     
 200d47c:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = 1;                                             
 200d480:	b8 10 20 01 	mov  1, %i4                                    
            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;
 200d484:	b4 10 3f ff 	mov  -1, %i2                                   
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
 200d488:	10 80 00 03 	b  200d494 <rtems_bdbuf_get_buffer_from_lru_list+0x1e0>
 200d48c:	b2 07 bf 80 	add  %fp, -128, %i1                            
  q->avl.left = q->avl.right = NULL;                                  
  q->avl.bal = 0;                                                     
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
 200d490:	82 10 00 04 	mov  %g4, %g1                                  
  {                                                                   
    if (p->avl.cache == -1)                                           
 200d494:	c8 48 60 10 	ldsb  [ %g1 + 0x10 ], %g4                      
 200d498:	c6 08 60 11 	ldub  [ %g1 + 0x11 ], %g3                      
 200d49c:	80 a1 3f ff 	cmp  %g4, -1                                   
    {                                                                 
      switch (p->avl.bal)                                             
 200d4a0:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
 200d4a4:	12 80 00 26 	bne  200d53c <rtems_bdbuf_get_buffer_from_lru_list+0x288>
 200d4a8:	87 38 e0 18 	sra  %g3, 0x18, %g3                            
    {                                                                 
      switch (p->avl.bal)                                             
 200d4ac:	80 a0 e0 00 	cmp  %g3, 0                                    
 200d4b0:	22 80 00 4d 	be,a   200d5e4 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
 200d4b4:	c8 28 60 11 	stb  %g4, [ %g1 + 0x11 ]                       
 200d4b8:	80 a0 e0 01 	cmp  %g3, 1                                    
 200d4bc:	02 80 00 28 	be  200d55c <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
 200d4c0:	80 a0 ff ff 	cmp  %g3, -1                                   
 200d4c4:	32 80 00 49 	bne,a   200d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
 200d4c8:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
        case 0:                                                       
          p->avl.bal = -1;                                            
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
 200d4cc:	10 80 00 02 	b  200d4d4 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
 200d4d0:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
 200d4d4:	c8 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g4                      
 200d4d8:	80 a1 3f ff 	cmp  %g4, -1                                   
 200d4dc:	12 80 00 05 	bne  200d4f0 <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
 200d4e0:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
          {                                                           
            p->avl.left = p1->avl.right;                              
 200d4e4:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
            p1->avl.right = p;                                        
 200d4e8:	10 80 00 26 	b  200d580 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
 200d4ec:	c2 20 e0 0c 	st  %g1, [ %g3 + 0xc ]                         
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
 200d4f0:	f0 01 20 08 	ld  [ %g4 + 8 ], %i0                           
            p2->avl.left = p1;                                        
 200d4f4:	c6 21 20 08 	st  %g3, [ %g4 + 8 ]                           
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
 200d4f8:	f0 20 e0 0c 	st  %i0, [ %g3 + 0xc ]                         
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
 200d4fc:	f0 01 20 0c 	ld  [ %g4 + 0xc ], %i0                         
            p2->avl.right = p;                                        
 200d500:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
 200d504:	f0 20 60 08 	st  %i0, [ %g1 + 8 ]                           
            p2->avl.right = p;                                        
            if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
 200d508:	f0 49 20 11 	ldsb  [ %g4 + 0x11 ], %i0                      
 200d50c:	80 a6 3f ff 	cmp  %i0, -1                                   
 200d510:	12 80 00 04 	bne  200d520 <rtems_bdbuf_get_buffer_from_lru_list+0x26c>
 200d514:	b6 10 00 04 	mov  %g4, %i3                                  
 200d518:	10 80 00 03 	b  200d524 <rtems_bdbuf_get_buffer_from_lru_list+0x270>
 200d51c:	f8 28 60 11 	stb  %i4, [ %g1 + 0x11 ]                       
 200d520:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
 200d524:	c2 49 20 11 	ldsb  [ %g4 + 0x11 ], %g1                      
 200d528:	80 a0 60 01 	cmp  %g1, 1                                    
 200d52c:	32 80 00 2a 	bne,a   200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
 200d530:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
 200d534:	10 80 00 28 	b  200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
 200d538:	f4 28 e0 11 	stb  %i2, [ %g3 + 0x11 ]                       
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
 200d53c:	80 a0 e0 00 	cmp  %g3, 0                                    
 200d540:	22 80 00 29 	be,a   200d5e4 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
 200d544:	f8 28 60 11 	stb  %i4, [ %g1 + 0x11 ]                       
 200d548:	80 a0 e0 01 	cmp  %g3, 1                                    
 200d54c:	02 80 00 06 	be  200d564 <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
 200d550:	80 a0 ff ff 	cmp  %g3, -1                                   
 200d554:	32 80 00 25 	bne,a   200d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
 200d558:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
 200d55c:	10 80 00 20 	b  200d5dc <rtems_bdbuf_get_buffer_from_lru_list+0x328>
 200d560:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
        case 0:                                                       
          p->avl.bal = 1;                                             
          break;                                                      
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
 200d564:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
          if (p1->avl.bal == 1) /* simple RR-turn */                  
 200d568:	c8 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g4                      
 200d56c:	80 a1 20 01 	cmp  %g4, 1                                    
 200d570:	12 80 00 07 	bne  200d58c <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
 200d574:	c8 00 e0 08 	ld  [ %g3 + 8 ], %g4                           
          {                                                           
            p->avl.right = p1->avl.left;                              
 200d578:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
            p1->avl.left = p;                                         
 200d57c:	c2 20 e0 08 	st  %g1, [ %g3 + 8 ]                           
            p->avl.bal = 0;                                           
 200d580:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
 200d584:	10 80 00 14 	b  200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
 200d588:	b6 10 00 03 	mov  %g3, %i3                                  
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
 200d58c:	f0 01 20 0c 	ld  [ %g4 + 0xc ], %i0                         
            p2->avl.right = p1;                                       
 200d590:	c6 21 20 0c 	st  %g3, [ %g4 + 0xc ]                         
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
 200d594:	f0 20 e0 08 	st  %i0, [ %g3 + 8 ]                           
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
 200d598:	f0 01 20 08 	ld  [ %g4 + 8 ], %i0                           
            p2->avl.left = p;                                         
 200d59c:	c2 21 20 08 	st  %g1, [ %g4 + 8 ]                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
 200d5a0:	f0 20 60 0c 	st  %i0, [ %g1 + 0xc ]                         
            p2->avl.left = p;                                         
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
 200d5a4:	f0 49 20 11 	ldsb  [ %g4 + 0x11 ], %i0                      
 200d5a8:	80 a6 20 01 	cmp  %i0, 1                                    
 200d5ac:	12 80 00 04 	bne  200d5bc <rtems_bdbuf_get_buffer_from_lru_list+0x308><== ALWAYS TAKEN
 200d5b0:	b6 10 00 04 	mov  %g4, %i3                                  
 200d5b4:	10 80 00 03 	b  200d5c0 <rtems_bdbuf_get_buffer_from_lru_list+0x30c><== NOT EXECUTED
 200d5b8:	f4 28 60 11 	stb  %i2, [ %g1 + 0x11 ]                       <== NOT EXECUTED
 200d5bc:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
            if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
 200d5c0:	c2 49 20 11 	ldsb  [ %g4 + 0x11 ], %g1                      
 200d5c4:	80 a0 7f ff 	cmp  %g1, -1                                   
 200d5c8:	32 80 00 03 	bne,a   200d5d4 <rtems_bdbuf_get_buffer_from_lru_list+0x320><== ALWAYS TAKEN
 200d5cc:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
 200d5d0:	f8 28 e0 11 	stb  %i4, [ %g3 + 0x11 ]                       <== NOT EXECUTED
            p = p2;                                                   
          }                                                           
          p->avl.bal = 0;                                             
 200d5d4:	c0 2e e0 11 	clrb  [ %i3 + 0x11 ]                           
 200d5d8:	82 10 00 1b 	mov  %i3, %g1                                  
          modified = false;                                           
 200d5dc:	10 80 00 03 	b  200d5e8 <rtems_bdbuf_get_buffer_from_lru_list+0x334>
 200d5e0:	86 10 20 00 	clr  %g3                                       
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
 200d5e4:	86 10 20 01 	mov  1, %g3                                    
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
 200d5e8:	80 a7 40 19 	cmp  %i5, %i1                                  
 200d5ec:	28 80 00 09 	bleu,a   200d610 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
 200d5f0:	07 00 80 85 	sethi  %hi(0x2021400), %g3                     
    {                                                                 
      p = *--buf_prev;                                                
 200d5f4:	c8 07 7f fc 	ld  [ %i5 + -4 ], %g4                          
                                                                      
      if (p->avl.cache == -1)                                         
 200d5f8:	f6 49 20 10 	ldsb  [ %g4 + 0x10 ], %i3                      
 200d5fc:	80 a6 ff ff 	cmp  %i3, -1                                   
 200d600:	32 80 00 06 	bne,a   200d618 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
 200d604:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
      {                                                               
        p->avl.left = q;                                              
 200d608:	10 80 00 04 	b  200d618 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
 200d60c:	c2 21 20 08 	st  %g1, [ %g4 + 8 ]                           
        p->avl.right = q;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
 200d610:	10 80 00 09 	b  200d634 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
 200d614:	c2 20 e2 88 	st  %g1, [ %g3 + 0x288 ]                       
  q->avl.left = q->avl.right = NULL;                                  
  q->avl.bal = 0;                                                     
  modified = true;                                                    
  buf_prev--;                                                         
                                                                      
  while (modified)                                                    
 200d618:	80 88 e0 ff 	btst  0xff, %g3                                
 200d61c:	12 bf ff 9d 	bne  200d490 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
 200d620:	ba 07 7f fc 	add  %i5, -4, %i5                              
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200d624:	10 80 00 05 	b  200d638 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
 200d628:	82 10 20 01 	mov  1, %g1                                    
  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);                    
 200d62c:	7f ff fd 0a 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200d630:	90 10 20 08 	mov  8, %o0                                    <== NOT EXECUTED
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200d634:	82 10 20 01 	mov  1, %g1                                    
 200d638:	10 80 00 06 	b  200d650 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
 200d63c:	c2 20 a0 20 	st  %g1, [ %g2 + 0x20 ]                        
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))               
 200d640:	80 a7 00 11 	cmp  %i4, %l1                                  
 200d644:	32 bf ff 23 	bne,a   200d2d0 <rtems_bdbuf_get_buffer_from_lru_list+0x1c>
 200d648:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
    }                                                                 
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
 200d64c:	84 10 20 00 	clr  %g2                                       
}                                                                     
 200d650:	81 c7 e0 08 	ret                                            
 200d654:	91 e8 00 02 	restore  %g0, %g2, %o0                         
                                                                      

0200e350 <rtems_bdbuf_init>: * * @return rtems_status_code The initialisation status. */ rtems_status_code rtems_bdbuf_init (void) {
 200e350:	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())                               
 200e354:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
 200e358:	c2 00 63 18 	ld  [ %g1 + 0x318 ], %g1	! 2021f18 <_Per_CPU_Information+0x8>
 200e35c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e360:	12 80 00 16 	bne  200e3b8 <rtems_bdbuf_init+0x68>           <== NEVER TAKEN
 200e364:	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)       
 200e368:	35 00 80 7a 	sethi  %hi(0x201e800), %i2                     
 200e36c:	b4 16 a3 f8 	or  %i2, 0x3f8, %i2	! 201ebf8 <rtems_bdbuf_configuration>
 200e370:	f2 06 a0 28 	ld  [ %i2 + 0x28 ], %i1                        
 200e374:	f8 06 a0 24 	ld  [ %i2 + 0x24 ], %i4                        
 200e378:	90 10 00 19 	mov  %i1, %o0                                  
 200e37c:	92 10 00 1c 	mov  %i4, %o1                                  
 200e380:	40 00 39 ad 	call  201ca34 <.urem>                          
 200e384:	b0 10 20 0a 	mov  0xa, %i0                                  
 200e388:	80 a2 20 00 	cmp  %o0, 0                                    
 200e38c:	12 80 01 01 	bne  200e790 <rtems_bdbuf_init+0x440>          <== NEVER TAKEN
 200e390:	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 ();                      
 200e394:	7f ff f9 e8 	call  200cb34 <rtems_bdbuf_disable_preemption> 
 200e398:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     
  if (bdbuf_cache.initialised)                                        
 200e39c:	ba 17 62 4c 	or  %i5, 0x24c, %i5	! 202164c <bdbuf_cache>    
 200e3a0:	c2 0f 60 95 	ldub  [ %i5 + 0x95 ], %g1                      
 200e3a4:	80 a0 60 00 	cmp  %g1, 0                                    
 200e3a8:	02 80 00 06 	be  200e3c0 <rtems_bdbuf_init+0x70>            <== ALWAYS TAKEN
 200e3ac:	b6 10 00 08 	mov  %o0, %i3                                  
  {                                                                   
    rtems_bdbuf_restore_preemption (prev_mode);                       
 200e3b0:	7f ff f9 ee 	call  200cb68 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
 200e3b4:	b0 10 20 0c 	mov  0xc, %i0                                  <== NOT EXECUTED
    return RTEMS_RESOURCE_IN_USE;                                     
 200e3b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e3bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));                       
 200e3c0:	92 10 20 00 	clr  %o1                                       
 200e3c4:	94 10 20 98 	mov  0x98, %o2                                 
 200e3c8:	40 00 18 18 	call  2014428 <memset>                         
 200e3cc:	90 10 00 1d 	mov  %i5, %o0                                  
  bdbuf_cache.initialised = true;                                     
 200e3d0:	82 10 20 01 	mov  1, %g1                                    
  rtems_bdbuf_restore_preemption (prev_mode);                         
 200e3d4:	90 10 00 1b 	mov  %i3, %o0                                  
 200e3d8:	7f ff f9 e4 	call  200cb68 <rtems_bdbuf_restore_preemption> 
 200e3dc:	c2 2f 60 95 	stb  %g1, [ %i5 + 0x95 ]                       
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200e3e0:	82 07 60 0c 	add  %i5, 0xc, %g1                             
 200e3e4:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200e3e8:	82 07 60 08 	add  %i5, 8, %g1                               
 200e3ec:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200e3f0:	82 07 60 44 	add  %i5, 0x44, %g1                            
 200e3f4:	c2 27 60 40 	st  %g1, [ %i5 + 0x40 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200e3f8:	82 07 60 40 	add  %i5, 0x40, %g1                            
 200e3fc:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200e400:	82 07 60 50 	add  %i5, 0x50, %g1                            
 200e404:	c2 27 60 4c 	st  %g1, [ %i5 + 0x4c ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200e408:	82 07 60 4c 	add  %i5, 0x4c, %g1                            
 200e40c:	c2 27 60 54 	st  %g1, [ %i5 + 0x54 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200e410:	82 07 60 5c 	add  %i5, 0x5c, %g1                            
 200e414:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200e418:	82 07 60 58 	add  %i5, 0x58, %g1                            
 200e41c:	c2 27 60 60 	st  %g1, [ %i5 + 0x60 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200e420:	82 07 60 8c 	add  %i5, 0x8c, %g1                            
 200e424:	c2 27 60 88 	st  %g1, [ %i5 + 0x88 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200e428:	82 07 60 88 	add  %i5, 0x88, %g1                            
   */                                                                 
  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;                        
 200e42c:	c0 27 60 38 	clr  [ %i5 + 0x38 ]                            
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
 200e430:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
 200e434:	c0 27 60 44 	clr  [ %i5 + 0x44 ]                            
 200e438:	c0 27 60 50 	clr  [ %i5 + 0x50 ]                            
 200e43c:	c0 27 60 5c 	clr  [ %i5 + 0x5c ]                            
 200e440:	c0 27 60 8c 	clr  [ %i5 + 0x8c ]                            
  tail->previous = head;                                              
 200e444:	c2 27 60 90 	st  %g1, [ %i5 + 0x90 ]                        
  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'), 
 200e448:	37 10 91 10 	sethi  %hi(0x42444000), %i3                    
 200e44c:	92 10 20 01 	mov  1, %o1                                    
 200e450:	90 16 e3 6c 	or  %i3, 0x36c, %o0                            
 200e454:	94 10 20 54 	mov  0x54, %o2                                 
 200e458:	96 10 20 00 	clr  %o3                                       
 200e45c:	7f ff e9 0a 	call  2008884 <rtems_semaphore_create>         
 200e460:	98 07 60 28 	add  %i5, 0x28, %o4                            
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.lock);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
 200e464:	80 a2 20 00 	cmp  %o0, 0                                    
 200e468:	12 80 00 a3 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e46c:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    goto error;                                                       
                                                                      
  rtems_bdbuf_lock_cache ();                                          
 200e470:	7f ff f9 8a 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200e474:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'), 
 200e478:	90 16 e3 73 	or  %i3, 0x373, %o0                            
 200e47c:	92 10 20 01 	mov  1, %o1                                    
 200e480:	94 10 20 54 	mov  0x54, %o2                                 
 200e484:	96 10 20 00 	clr  %o3                                       
 200e488:	7f ff e8 ff 	call  2008884 <rtems_semaphore_create>         
 200e48c:	98 07 60 2c 	add  %i5, 0x2c, %o4                            
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.sync_lock);               
  if (sc != RTEMS_SUCCESSFUL)                                         
 200e490:	80 a2 20 00 	cmp  %o0, 0                                    
 200e494:	12 80 00 98 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e498:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'), 
 200e49c:	90 16 e3 61 	or  %i3, 0x361, %o0                            
 200e4a0:	92 10 20 00 	clr  %o1                                       
 200e4a4:	94 10 20 24 	mov  0x24, %o2                                 
 200e4a8:	96 10 20 00 	clr  %o3                                       
 200e4ac:	7f ff e8 f6 	call  2008884 <rtems_semaphore_create>         
 200e4b0:	98 07 60 68 	add  %i5, 0x68, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.access_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
 200e4b4:	80 a2 20 00 	cmp  %o0, 0                                    
 200e4b8:	12 80 00 8f 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e4bc:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'), 
 200e4c0:	90 16 e3 74 	or  %i3, 0x374, %o0                            
 200e4c4:	92 10 20 00 	clr  %o1                                       
 200e4c8:	94 10 20 24 	mov  0x24, %o2                                 
 200e4cc:	96 10 20 00 	clr  %o3                                       
 200e4d0:	7f ff e8 ed 	call  2008884 <rtems_semaphore_create>         
 200e4d4:	98 07 60 70 	add  %i5, 0x70, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.transfer_waiters.sema);   
  if (sc != RTEMS_SUCCESSFUL)                                         
 200e4d8:	80 a2 20 00 	cmp  %o0, 0                                    
 200e4dc:	12 80 00 86 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e4e0:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'), 
 200e4e4:	90 16 e3 62 	or  %i3, 0x362, %o0                            
 200e4e8:	92 10 20 00 	clr  %o1                                       
 200e4ec:	94 10 20 24 	mov  0x24, %o2                                 
 200e4f0:	96 10 20 00 	clr  %o3                                       
 200e4f4:	7f ff e8 e4 	call  2008884 <rtems_semaphore_create>         
 200e4f8:	98 07 60 78 	add  %i5, 0x78, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.buffer_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
 200e4fc:	80 a2 20 00 	cmp  %o0, 0                                    
 200e500:	12 80 00 7d 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e504:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
 200e508:	d0 06 a0 20 	ld  [ %i2 + 0x20 ], %o0                        
 200e50c:	40 00 38 9e 	call  201c784 <.udiv>                          
 200e510:	92 10 00 1c 	mov  %i4, %o1                                  
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
 200e514:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
 200e518:	b6 10 00 08 	mov  %o0, %i3                                  
    goto error;                                                       
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
 200e51c:	d0 27 60 1c 	st  %o0, [ %i5 + 0x1c ]                        
    bdbuf_config.size / bdbuf_config.buffer_min;                      
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
 200e520:	40 00 38 99 	call  201c784 <.udiv>                          
 200e524:	90 10 00 19 	mov  %i1, %o0                                  
 200e528:	92 10 00 08 	mov  %o0, %o1                                  
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
    bdbuf_config.size / bdbuf_config.buffer_min;                      
  bdbuf_cache.max_bds_per_group =                                     
 200e52c:	d0 27 60 20 	st  %o0, [ %i5 + 0x20 ]                        
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
  bdbuf_cache.group_count =                                           
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
 200e530:	40 00 38 95 	call  201c784 <.udiv>                          
 200e534:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
 200e538:	92 10 00 1b 	mov  %i3, %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 =                                           
 200e53c:	d0 27 60 7c 	st  %o0, [ %i5 + 0x7c ]                        
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
 200e540:	b4 10 00 08 	mov  %o0, %i2                                  
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
 200e544:	7f ff d7 e2 	call  20044cc <calloc>                         
 200e548:	90 10 20 38 	mov  0x38, %o0                                 
                            bdbuf_cache.buffer_min_count);            
  if (!bdbuf_cache.bds)                                               
 200e54c:	80 a2 20 00 	cmp  %o0, 0                                    
 200e550:	02 80 00 68 	be  200e6f0 <rtems_bdbuf_init+0x3a0>           <== NEVER TAKEN
 200e554:	d0 27 60 14 	st  %o0, [ %i5 + 0x14 ]                        
    goto error;                                                       
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),            
 200e558:	90 10 20 14 	mov  0x14, %o0                                 
 200e55c:	7f ff d7 dc 	call  20044cc <calloc>                         
 200e560:	92 10 00 1a 	mov  %i2, %o1                                  
                               bdbuf_cache.group_count);              
  if (!bdbuf_cache.groups)                                            
 200e564:	80 a2 20 00 	cmp  %o0, 0                                    
 200e568:	02 80 00 62 	be  200e6f0 <rtems_bdbuf_init+0x3a0>           <== NEVER TAKEN
 200e56c:	d0 27 60 80 	st  %o0, [ %i5 + 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)
 200e570:	92 10 00 1c 	mov  %i4, %o1                                  
 200e574:	40 00 38 4a 	call  201c69c <.umul>                          
 200e578:	90 10 00 1b 	mov  %i3, %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,                 
 200e57c:	92 10 20 20 	mov  0x20, %o1                                 
                      cache_aligment,                                 
                      bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
 200e580:	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,                 
 200e584:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
 200e588:	40 00 07 49 	call  20102ac <rtems_memalign>                 
 200e58c:	90 12 22 64 	or  %o0, 0x264, %o0	! 2021664 <bdbuf_cache+0x18>
 200e590:	80 a2 20 00 	cmp  %o0, 0                                    
 200e594:	12 80 00 58 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e598:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
                                                                      
  /*                                                                  
   * 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,                             
 200e59c:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200e5a0:	82 10 62 4c 	or  %g1, 0x24c, %g1	! 202164c <bdbuf_cache>    
 200e5a4:	f6 00 60 80 	ld  [ %g1 + 0x80 ], %i3                        
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
 200e5a8:	f4 00 60 14 	ld  [ %g1 + 0x14 ], %i2                        
    bd->group  = group;                                               
    bd->buffer = buffer;                                              
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);     
                                                                      
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
 200e5ac:	e4 00 60 20 	ld  [ %g1 + 0x20 ], %l2                        
  /*                                                                  
   * 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;          
 200e5b0:	e0 00 60 18 	ld  [ %g1 + 0x18 ], %l0                        
       b < bdbuf_cache.buffer_min_count;                              
 200e5b4:	e6 00 60 1c 	ld  [ %g1 + 0x1c ], %l3                        
    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))                          
 200e5b8:	a8 04 bf ff 	add  %l2, -1, %l4                              
  /*                                                                  
   * 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;          
 200e5bc:	ba 10 00 1a 	mov  %i2, %i5                                  
                                                                      
  /*                                                                  
   * 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,                             
 200e5c0:	b0 10 00 1b 	mov  %i3, %i0                                  
 200e5c4:	b2 10 20 00 	clr  %i1                                       
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 200e5c8:	a2 10 00 01 	mov  %g1, %l1                                  
 200e5cc:	10 80 00 12 	b  200e614 <rtems_bdbuf_init+0x2c4>            
 200e5d0:	aa 00 60 44 	add  %g1, 0x44, %l5                            
         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;                                               
 200e5d4:	f0 27 60 28 	st  %i0, [ %i5 + 0x28 ]                        
    bd->buffer = buffer;                                              
 200e5d8:	e0 27 60 1c 	st  %l0, [ %i5 + 0x1c ]                        
 200e5dc:	c2 04 60 48 	ld  [ %l1 + 0x48 ], %g1                        
                                                                      
  the_node->next = tail;                                              
 200e5e0:	ea 27 40 00 	st  %l5, [ %i5 ]                               
  tail->previous = the_node;                                          
 200e5e4:	fa 24 60 48 	st  %i5, [ %l1 + 0x48 ]                        
  old_last->next = the_node;                                          
 200e5e8:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  the_node->previous = old_last;                                      
 200e5ec:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);     
                                                                      
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
 200e5f0:	90 10 00 19 	mov  %i1, %o0                                  
 200e5f4:	40 00 39 10 	call  201ca34 <.urem>                          
 200e5f8:	92 10 00 12 	mov  %l2, %o1                                  
 200e5fc:	80 a2 00 14 	cmp  %o0, %l4                                  
 200e600:	22 80 00 02 	be,a   200e608 <rtems_bdbuf_init+0x2b8>        
 200e604:	b0 06 20 14 	add  %i0, 0x14, %i0                            
   * 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)                  
 200e608:	b2 06 60 01 	inc  %i1                                       
 200e60c:	ba 07 60 38 	add  %i5, 0x38, %i5                            
 200e610:	a0 04 00 1c 	add  %l0, %i4, %l0                             
                                                                      
  /*                                                                  
   * 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,                             
 200e614:	80 a6 40 13 	cmp  %i1, %l3                                  
 200e618:	32 bf ff ef 	bne,a   200e5d4 <rtems_bdbuf_init+0x284>       
 200e61c:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
 200e620:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200e624:	82 10 62 4c 	or  %g1, 0x24c, %g1	! 202164c <bdbuf_cache>    
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
 200e628:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
 200e62c:	c6 00 60 7c 	ld  [ %g1 + 0x7c ], %g3                        
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
 200e630:	83 28 a0 03 	sll  %g2, 3, %g1                               
 200e634:	89 28 a0 06 	sll  %g2, 6, %g4                               
 200e638:	88 21 00 01 	sub  %g4, %g1, %g4                             
 200e63c:	10 80 00 06 	b  200e654 <rtems_bdbuf_init+0x304>            
 200e640:	82 10 20 00 	clr  %g1                                       
  {                                                                   
    group->bds_per_group = bdbuf_cache.max_bds_per_group;             
 200e644:	c4 26 e0 08 	st  %g2, [ %i3 + 8 ]                           
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
       b++,                                                           
 200e648:	82 00 60 01 	inc  %g1                                       
         group++,                                                     
 200e64c:	b6 06 e0 14 	add  %i3, 0x14, %i3                            
         bd += bdbuf_cache.max_bds_per_group)                         
 200e650:	b4 06 80 04 	add  %i2, %g4, %i2                             
    if ((b % bdbuf_cache.max_bds_per_group) ==                        
        (bdbuf_cache.max_bds_per_group - 1))                          
      group++;                                                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
 200e654:	80 a0 40 03 	cmp  %g1, %g3                                  
 200e658:	32 bf ff fb 	bne,a   200e644 <rtems_bdbuf_init+0x2f4>       
 200e65c:	f4 26 e0 10 	st  %i2, [ %i3 + 0x10 ]                        
   * 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'), 
 200e660:	35 00 80 7a 	sethi  %hi(0x201e800), %i2                     
 200e664:	b8 16 a3 f8 	or  %i2, 0x3f8, %i4	! 201ebf8 <rtems_bdbuf_configuration>
 200e668:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
                                                                      
  /*                                                                  
   * Create and start swapout task. This task will create and manage the worker
   * threads.                                                         
   */                                                                 
  bdbuf_cache.swapout_enabled = true;                                 
 200e66c:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     
 200e670:	b6 10 20 01 	mov  1, %i3                                    
 200e674:	ba 17 62 4c 	or  %i5, 0x24c, %i5                            
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
 200e678:	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;                                 
 200e67c:	f6 2f 60 04 	stb  %i3, [ %i5 + 4 ]                          
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
 200e680:	90 12 23 50 	or  %o0, 0x350, %o0                            
 200e684:	15 00 80 37 	sethi  %hi(0x200dc00), %o2                     
 200e688:	96 10 20 00 	clr  %o3                                       
 200e68c:	94 12 a1 08 	or  %o2, 0x108, %o2                            
 200e690:	7f ff f9 b9 	call  200cd74 <rtems_bdbuf_create_task.constprop.10>
 200e694:	98 10 00 1d 	mov  %i5, %o4                                  
                                bdbuf_config.swapout_priority,        
                                RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
                                rtems_bdbuf_swapout_task,             
                                0,                                    
                                &bdbuf_cache.swapout);                
  if (sc != RTEMS_SUCCESSFUL)                                         
 200e698:	80 a2 20 00 	cmp  %o0, 0                                    
 200e69c:	12 80 00 16 	bne  200e6f4 <rtems_bdbuf_init+0x3a4>          <== NEVER TAKEN
 200e6a0:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    goto error;                                                       
                                                                      
  if (bdbuf_config.max_read_ahead_blocks > 0)                         
 200e6a4:	c2 06 a3 f8 	ld  [ %i2 + 0x3f8 ], %g1                       
 200e6a8:	80 a0 60 00 	cmp  %g1, 0                                    
 200e6ac:	32 80 00 06 	bne,a   200e6c4 <rtems_bdbuf_init+0x374>       
 200e6b0:	d2 07 20 2c 	ld  [ %i4 + 0x2c ], %o1                        
                                  &bdbuf_cache.read_ahead_task);      
    if (sc != RTEMS_SUCCESSFUL)                                       
      goto error;                                                     
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200e6b4:	7f ff f9 0e 	call  200caec <rtems_bdbuf_unlock_cache>       
 200e6b8:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200e6bc:	81 c7 e0 08 	ret                                            
 200e6c0:	81 e8 00 00 	restore                                        
  if (sc != RTEMS_SUCCESSFUL)                                         
    goto error;                                                       
                                                                      
  if (bdbuf_config.max_read_ahead_blocks > 0)                         
  {                                                                   
    bdbuf_cache.read_ahead_enabled = true;                            
 200e6c4:	f6 2f 60 94 	stb  %i3, [ %i5 + 0x94 ]                       
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
 200e6c8:	11 10 94 91 	sethi  %hi(0x42524400), %o0                    
 200e6cc:	15 00 80 38 	sethi  %hi(0x200e000), %o2                     
 200e6d0:	90 12 20 41 	or  %o0, 0x41, %o0                             
 200e6d4:	94 12 a1 80 	or  %o2, 0x180, %o2                            
 200e6d8:	96 10 20 00 	clr  %o3                                       
 200e6dc:	7f ff f9 a6 	call  200cd74 <rtems_bdbuf_create_task.constprop.10>
 200e6e0:	98 07 60 84 	add  %i5, 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)                                       
 200e6e4:	80 a2 20 00 	cmp  %o0, 0                                    
 200e6e8:	02 bf ff f3 	be  200e6b4 <rtems_bdbuf_init+0x364>           <== ALWAYS TAKEN
 200e6ec:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
                                                                      
error:                                                                
                                                                      
  if (bdbuf_cache.read_ahead_task != 0)                               
 200e6f0:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
 200e6f4:	d0 00 62 d0 	ld  [ %g1 + 0x2d0 ], %o0	! 20216d0 <bdbuf_cache+0x84><== NOT EXECUTED
 200e6f8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 200e6fc:	02 80 00 05 	be  200e710 <rtems_bdbuf_init+0x3c0>           <== NOT EXECUTED
 200e700:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.read_ahead_task);                  
 200e704:	7f ff e9 d2 	call  2008e4c <rtems_task_delete>              <== NOT EXECUTED
 200e708:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
 200e70c:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
 200e710:	d0 00 62 4c 	ld  [ %g1 + 0x24c ], %o0	! 202164c <bdbuf_cache><== NOT EXECUTED
 200e714:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 200e718:	02 80 00 04 	be  200e728 <rtems_bdbuf_init+0x3d8>           <== NOT EXECUTED
 200e71c:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.swapout);                          
 200e720:	7f ff e9 cb 	call  2008e4c <rtems_task_delete>              <== NOT EXECUTED
 200e724:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  free (bdbuf_cache.buffers);                                         
 200e728:	ba 17 62 4c 	or  %i5, 0x24c, %i5                            <== NOT EXECUTED
 200e72c:	7f ff d8 3c 	call  200481c <free>                           <== NOT EXECUTED
 200e730:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        <== NOT EXECUTED
  free (bdbuf_cache.groups);                                          
 200e734:	7f ff d8 3a 	call  200481c <free>                           <== NOT EXECUTED
 200e738:	d0 07 60 80 	ld  [ %i5 + 0x80 ], %o0                        <== NOT EXECUTED
  free (bdbuf_cache.bds);                                             
 200e73c:	7f ff d8 38 	call  200481c <free>                           <== NOT EXECUTED
 200e740:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        <== NOT EXECUTED
                                                                      
  rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);           
 200e744:	7f ff e8 be 	call  2008a3c <rtems_semaphore_delete>         <== NOT EXECUTED
 200e748:	d0 07 60 78 	ld  [ %i5 + 0x78 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);           
 200e74c:	7f ff e8 bc 	call  2008a3c <rtems_semaphore_delete>         <== NOT EXECUTED
 200e750:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);         
 200e754:	7f ff e8 ba 	call  2008a3c <rtems_semaphore_delete>         <== NOT EXECUTED
 200e758:	d0 07 60 70 	ld  [ %i5 + 0x70 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.sync_lock);                     
 200e75c:	7f ff e8 b8 	call  2008a3c <rtems_semaphore_delete>         <== NOT EXECUTED
 200e760:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.lock != 0)                                          
 200e764:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        <== NOT EXECUTED
 200e768:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 200e76c:	02 80 00 07 	be  200e788 <rtems_bdbuf_init+0x438>           <== NOT EXECUTED
 200e770:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
 200e774:	7f ff f8 de 	call  200caec <rtems_bdbuf_unlock_cache>       <== NOT EXECUTED
 200e778:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_semaphore_delete (bdbuf_cache.lock);                        
 200e77c:	7f ff e8 b0 	call  2008a3c <rtems_semaphore_delete>         <== NOT EXECUTED
 200e780:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
  }                                                                   
                                                                      
  bdbuf_cache.initialised = false;                                    
 200e784:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     <== NOT EXECUTED
                                                                      
  return RTEMS_UNSATISFIED;                                           
 200e788:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
    rtems_semaphore_delete (bdbuf_cache.lock);                        
  }                                                                   
                                                                      
  bdbuf_cache.initialised = false;                                    
 200e78c:	c0 28 62 e1 	clrb  [ %g1 + 0x2e1 ]                          <== NOT EXECUTED
                                                                      
  return RTEMS_UNSATISFIED;                                           
}                                                                     
 200e790:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200e794:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200ca68 <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) {
 200ca68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_semaphore_obtain (lock,                
 200ca6c:	92 10 20 00 	clr  %o1                                       
 200ca70:	90 10 00 18 	mov  %i0, %o0                                  
 200ca74:	7f ff f0 21 	call  2008af8 <rtems_semaphore_obtain>         
 200ca78:	94 10 20 00 	clr  %o2                                       
                                                 RTEMS_WAIT,          
                                                 RTEMS_NO_TIMEOUT);   
  if (sc != RTEMS_SUCCESSFUL)                                         
 200ca7c:	80 a2 20 00 	cmp  %o0, 0                                    
 200ca80:	02 80 00 04 	be  200ca90 <rtems_bdbuf_lock+0x28>            <== ALWAYS TAKEN
 200ca84:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (fatal_error_code);                             
 200ca88:	7f ff ff f3 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200ca8c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 200ca90:	81 c7 e0 08 	ret                                            
 200ca94:	81 e8 00 00 	restore                                        
                                                                      

0200ed24 <rtems_bdbuf_purge_dev>: } } void rtems_bdbuf_purge_dev (rtems_disk_device *dd) {
 200ed24:	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;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200ed28:	82 07 bf 74 	add  %fp, -140, %g1                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200ed2c:	b6 07 bf 78 	add  %fp, -136, %i3                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200ed30:	c2 27 bf 7c 	st  %g1, [ %fp + -132 ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200ed34:	f6 27 bf 74 	st  %i3, [ %fp + -140 ]                        
  rtems_chain_control purge_list;                                     
                                                                      
  rtems_chain_initialize_empty (&purge_list);                         
  rtems_bdbuf_lock_cache ();                                          
 200ed38:	7f ff f7 58 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200ed3c:	c0 27 bf 78 	clr  [ %fp + -136 ]                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)                  
{                                                                     
  rtems_bdbuf_read_ahead_cancel (dd);                                 
 200ed40:	7f ff fd 5c 	call  200e2b0 <rtems_bdbuf_read_ahead_cancel>  
 200ed44:	90 10 00 18 	mov  %i0, %o0                                  
  dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;          
 200ed48:	82 10 3f ff 	mov  -1, %g1                                   
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;                         
 200ed4c:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
 200ed50:	35 00 80 32 	sethi  %hi(0x200c800), %i2                     
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;                         
 200ed54:	90 12 22 4c 	or  %o0, 0x24c, %o0                            
                                                                      
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;          
 200ed58:	c2 26 20 6c 	st  %g1, [ %i0 + 0x6c ]                        
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;                         
 200ed5c:	fa 02 20 3c 	ld  [ %o0 + 0x3c ], %i5                        
                                                                      
  *prev = NULL;                                                       
 200ed60:	c0 27 bf 80 	clr  [ %fp + -128 ]                            
static void                                                           
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;                                  
 200ed64:	b8 07 bf 80 	add  %fp, -128, %i4                            
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
 200ed68:	b4 16 a1 d8 	or  %i2, 0x1d8, %i2                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200ed6c:	b2 10 20 06 	mov  6, %i1                                    
 200ed70:	a0 10 20 0a 	mov  0xa, %l0                                  
        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);           
 200ed74:	10 80 00 3a 	b  200ee5c <rtems_bdbuf_purge_dev+0x138>       
 200ed78:	a2 02 20 6c 	add  %o0, 0x6c, %l1                            
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
 200ed7c:	80 a0 40 18 	cmp  %g1, %i0                                  
 200ed80:	32 80 00 1e 	bne,a   200edf8 <rtems_bdbuf_purge_dev+0xd4>   
 200ed84:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    {                                                                 
      switch (cur->state)                                             
 200ed88:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 200ed8c:	80 a0 60 0a 	cmp  %g1, 0xa                                  
 200ed90:	18 80 00 17 	bgu  200edec <rtems_bdbuf_purge_dev+0xc8>      <== NEVER TAKEN
 200ed94:	83 28 60 02 	sll  %g1, 2, %g1                               
 200ed98:	c2 06 80 01 	ld  [ %i2 + %g1 ], %g1                         
 200ed9c:	81 c0 40 00 	jmp  %g1                                       
 200eda0:	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);           
 200eda4:	7f ff f7 e6 	call  200cd3c <rtems_bdbuf_wake>               
 200eda8:	90 10 00 11 	mov  %l1, %o0                                  
          /* Fall through */                                          
        case RTEMS_BDBUF_STATE_MODIFIED:                              
          rtems_bdbuf_group_release (cur);                            
 200edac:	7f ff f7 25 	call  200ca40 <rtems_bdbuf_group_release>      
 200edb0:	90 10 00 1d 	mov  %i5, %o0                                  
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200edb4:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 200edb8:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
  next->previous = previous;                                          
 200edbc:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 200edc0:	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;                              
 200edc4:	c2 07 bf 7c 	ld  [ %fp + -132 ], %g1                        
                                                                      
  the_node->next = tail;                                              
 200edc8:	f6 27 40 00 	st  %i3, [ %i5 ]                               
  tail->previous = the_node;                                          
 200edcc:	fa 27 bf 7c 	st  %i5, [ %fp + -132 ]                        
  old_last->next = the_node;                                          
 200edd0:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  the_node->previous = old_last;                                      
 200edd4:	10 80 00 08 	b  200edf4 <rtems_bdbuf_purge_dev+0xd0>        
 200edd8:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200eddc:	10 80 00 06 	b  200edf4 <rtems_bdbuf_purge_dev+0xd0>        
 200ede0:	e0 27 60 20 	st  %l0, [ %i5 + 0x20 ]                        
 200ede4:	10 80 00 04 	b  200edf4 <rtems_bdbuf_purge_dev+0xd0>        
 200ede8:	f2 27 60 20 	st  %i1, [ %i5 + 0x20 ]                        
        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);             
 200edec:	7f ff f7 1a 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200edf0:	90 10 20 17 	mov  0x17, %o0                                 <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    if (cur->avl.left != NULL)                                        
 200edf4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 200edf8:	80 a0 60 00 	cmp  %g1, 0                                    
 200edfc:	22 80 00 04 	be,a   200ee0c <rtems_bdbuf_purge_dev+0xe8>    
 200ee00:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
      *prev = cur;                                                    
 200ee04:	10 80 00 06 	b  200ee1c <rtems_bdbuf_purge_dev+0xf8>        
 200ee08:	fa 27 20 04 	st  %i5, [ %i4 + 4 ]                           
      /* Left */                                                      
      ++prev;                                                         
      *prev = cur;                                                    
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
 200ee0c:	80 a0 60 00 	cmp  %g1, 0                                    
 200ee10:	22 80 00 08 	be,a   200ee30 <rtems_bdbuf_purge_dev+0x10c>   
 200ee14:	c2 07 00 00 	ld  [ %i4 ], %g1                               
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
      *prev = cur;                                                    
 200ee18:	fa 27 20 04 	st  %i5, [ %i4 + 4 ]                           
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
 200ee1c:	10 80 00 0f 	b  200ee58 <rtems_bdbuf_purge_dev+0x134>       
 200ee20:	b8 07 20 04 	add  %i4, 4, %i4                               
      while (*prev != NULL                                            
             && (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
      {                                                               
        /* Up */                                                      
        cur = *prev;                                                  
        --prev;                                                       
 200ee24:	b8 07 3f fc 	add  %i4, -4, %i4                              
 200ee28:	ba 10 00 01 	mov  %g1, %i5                                  
      *prev = cur;                                                    
      cur = cur->avl.right;                                           
    }                                                                 
    else                                                              
    {                                                                 
      while (*prev != NULL                                            
 200ee2c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 200ee30:	80 a0 60 00 	cmp  %g1, 0                                    
 200ee34:	22 80 00 0a 	be,a   200ee5c <rtems_bdbuf_purge_dev+0x138>   
 200ee38:	ba 10 00 01 	mov  %g1, %i5                                  
             && (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
 200ee3c:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 200ee40:	80 a7 40 02 	cmp  %i5, %g2                                  
 200ee44:	02 bf ff f8 	be  200ee24 <rtems_bdbuf_purge_dev+0x100>      
 200ee48:	80 a0 a0 00 	cmp  %g2, 0                                    
 200ee4c:	22 bf ff f7 	be,a   200ee28 <rtems_bdbuf_purge_dev+0x104>   
 200ee50:	b8 07 3f fc 	add  %i4, -4, %i4                              
        cur = *prev;                                                  
        --prev;                                                       
      }                                                               
      if (*prev != NULL)                                              
        /* Right */                                                   
        cur = (*prev)->avl.right;                                     
 200ee54:	82 10 00 02 	mov  %g2, %g1                                  
 200ee58:	ba 10 00 01 	mov  %g1, %i5                                  
  rtems_bdbuf_buffer **prev = stack;                                  
  rtems_bdbuf_buffer *cur = bdbuf_cache.tree;                         
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
 200ee5c:	80 a7 60 00 	cmp  %i5, 0                                    
 200ee60:	32 bf ff c7 	bne,a   200ed7c <rtems_bdbuf_purge_dev+0x58>   
 200ee64:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)              
{                                                                     
  bool wake_buffer_waiters = false;                                   
 200ee68:	b8 10 20 00 	clr  %i4                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200ee6c:	10 80 00 0c 	b  200ee9c <rtems_bdbuf_purge_dev+0x178>       
 200ee70:	b6 10 20 01 	mov  1, %i3                                    
                                                                      
  while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)   
  {                                                                   
    rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;             
                                                                      
    if (bd->waiters == 0)                                             
 200ee74:	80 a0 60 00 	cmp  %g1, 0                                    
 200ee78:	22 80 00 02 	be,a   200ee80 <rtems_bdbuf_purge_dev+0x15c>   
 200ee7c:	b8 10 20 01 	mov  1, %i4                                    
static void                                                           
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)                   
{                                                                     
  rtems_bdbuf_make_empty (bd);                                        
                                                                      
  if (bd->waiters == 0)                                               
 200ee80:	80 a0 60 00 	cmp  %g1, 0                                    
 200ee84:	12 80 00 06 	bne  200ee9c <rtems_bdbuf_purge_dev+0x178>     
 200ee88:	f6 27 60 20 	st  %i3, [ %i5 + 0x20 ]                        
  {                                                                   
    rtems_bdbuf_remove_from_tree (bd);                                
 200ee8c:	7f ff f7 d1 	call  200cdd0 <rtems_bdbuf_remove_from_tree>   
 200ee90:	90 10 00 1d 	mov  %i5, %o0                                  
    rtems_bdbuf_make_free_and_add_to_lru_list (bd);                   
 200ee94:	7f ff f8 b5 	call  200d168 <rtems_bdbuf_make_free_and_add_to_lru_list>
 200ee98:	90 10 00 1d 	mov  %i5, %o0                                  
 200ee9c:	7f ff f6 da 	call  200ca04 <_Chain_Get_unprotected>         
 200eea0:	90 07 bf 74 	add  %fp, -140, %o0                            
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)              
{                                                                     
  bool wake_buffer_waiters = false;                                   
  rtems_chain_node *node = NULL;                                      
                                                                      
  while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)   
 200eea4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200eea8:	32 bf ff f3 	bne,a   200ee74 <rtems_bdbuf_purge_dev+0x150>  
 200eeac:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_discard_buffer (bd);                                  
  }                                                                   
                                                                      
  if (wake_buffer_waiters)                                            
 200eeb0:	80 8f 20 ff 	btst  0xff, %i4                                
 200eeb4:	02 80 00 04 	be  200eec4 <rtems_bdbuf_purge_dev+0x1a0>      
 200eeb8:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
 200eebc:	7f ff f7 a0 	call  200cd3c <rtems_bdbuf_wake>               
 200eec0:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 20216c0 <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 ();                                        
 200eec4:	7f ff f7 0a 	call  200caec <rtems_bdbuf_unlock_cache>       
 200eec8:	01 00 00 00 	nop                                            
 200eecc:	81 c7 e0 08 	ret                                            
 200eed0:	81 e8 00 00 	restore                                        
                                                                      

0200e85c <rtems_bdbuf_read>: rtems_status_code rtems_bdbuf_read (rtems_disk_device *dd, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
 200e85c:	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 ();                                          
 200e860:	7f ff f8 8e 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200e864:	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)                                        
 200e868:	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;                                    
 200e86c:	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)                                        
 200e870:	80 a6 40 01 	cmp  %i1, %g1                                  
 200e874:	1a 80 00 71 	bcc  200ea38 <rtems_bdbuf_read+0x1dc>          <== NEVER TAKEN
 200e878:	b0 10 20 04 	mov  4, %i0                                    
}                                                                     
                                                                      
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)                            
 200e87c:	d2 07 60 30 	ld  [ %i5 + 0x30 ], %o1                        
 200e880:	80 a2 60 00 	cmp  %o1, 0                                    
 200e884:	26 80 00 04 	bl,a   200e894 <rtems_bdbuf_read+0x38>         <== NEVER TAKEN
 200e888:	d6 07 60 24 	ld  [ %i5 + 0x24 ], %o3                        <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
 200e88c:	10 80 00 09 	b  200e8b0 <rtems_bdbuf_read+0x54>             
 200e890:	93 2e 40 09 	sll  %i1, %o1, %o1                             
    /*                                                                
     * 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); 
 200e894:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 200e898:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 200e89c:	40 00 39 12 	call  201cce4 <__muldi3>                       <== NOT EXECUTED
 200e8a0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 200e8a4:	d6 07 60 20 	ld  [ %i5 + 0x20 ], %o3                        <== NOT EXECUTED
 200e8a8:	40 00 3b 20 	call  201d528 <__udivdi3>                      <== NOT EXECUTED
 200e8ac:	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;
 200e8b0:	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);         
 200e8b4:	90 10 00 1d 	mov  %i5, %o0                                  
 200e8b8:	7f ff fb 7b 	call  200d6a4 <rtems_bdbuf_get_buffer_for_access>
 200e8bc:	92 02 40 01 	add  %o1, %g1, %o1                             
 200e8c0:	b8 10 00 08 	mov  %o0, %i4                                  
    switch (bd->state)                                                
 200e8c4:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
 200e8c8:	80 a2 20 02 	cmp  %o0, 2                                    
 200e8cc:	02 80 00 08 	be  200e8ec <rtems_bdbuf_read+0x90>            
 200e8d0:	80 a2 20 07 	cmp  %o0, 7                                    
 200e8d4:	02 80 00 0b 	be  200e900 <rtems_bdbuf_read+0xa4>            
 200e8d8:	80 a2 20 01 	cmp  %o0, 1                                    
 200e8dc:	12 80 00 2d 	bne  200e990 <rtems_bdbuf_read+0x134>          <== NEVER TAKEN
 200e8e0:	01 00 00 00 	nop                                            
      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;                                      
 200e8e4:	10 80 00 0e 	b  200e91c <rtems_bdbuf_read+0xc0>             
 200e8e8:	c2 07 60 48 	ld  [ %i5 + 0x48 ], %g1                        
                                                                      
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);         
    switch (bd->state)                                                
    {                                                                 
      case RTEMS_BDBUF_STATE_CACHED:                                  
        ++dd->stats.read_hits;                                        
 200e8ec:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
 200e8f0:	82 00 60 01 	inc  %g1                                       
 200e8f4:	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;                                                  
 200e8f8:	10 80 00 06 	b  200e910 <rtems_bdbuf_read+0xb4>             
 200e8fc:	82 10 20 03 	mov  3, %g1                                    
      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;                                        
 200e900:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
 200e904:	82 00 60 01 	inc  %g1                                       
 200e908:	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;                                                  
 200e90c:	82 10 20 04 	mov  4, %g1                                    
 200e910:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
 200e914:	10 80 00 21 	b  200e998 <rtems_bdbuf_read+0x13c>            
 200e918:	b0 10 20 00 	clr  %i0                                       
      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;                                      
 200e91c:	82 00 60 01 	inc  %g1                                       
 200e920:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
static void                                                           
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,            
                                    rtems_blkdev_bnum  block)         
{                                                                     
  if (dd->read_ahead.trigger != block)                                
 200e924:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
 200e928:	80 a0 40 19 	cmp  %g1, %i1                                  
 200e92c:	02 80 00 09 	be  200e950 <rtems_bdbuf_read+0xf4>            
 200e930:	90 10 00 1d 	mov  %i5, %o0                                  
  {                                                                   
    rtems_bdbuf_read_ahead_cancel (dd);                               
 200e934:	7f ff fe 5f 	call  200e2b0 <rtems_bdbuf_read_ahead_cancel>  
 200e938:	90 10 00 1d 	mov  %i5, %o0                                  
    dd->read_ahead.trigger = block + 1;                               
 200e93c:	82 06 60 01 	add  %i1, 1, %g1                               
 200e940:	c2 27 60 6c 	st  %g1, [ %i5 + 0x6c ]                        
    dd->read_ahead.next = block + 2;                                  
 200e944:	82 06 60 02 	add  %i1, 2, %g1                               
 200e948:	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);            
 200e94c:	90 10 00 1d 	mov  %i5, %o0                                  
 200e950:	92 10 00 1c 	mov  %i4, %o1                                  
 200e954:	7f ff fd d8 	call  200e0b4 <rtems_bdbuf_execute_read_request>
 200e958:	94 10 20 01 	mov  1, %o2                                    
        if (sc == RTEMS_SUCCESSFUL)                                   
 200e95c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200e960:	32 80 00 0e 	bne,a   200e998 <rtems_bdbuf_read+0x13c>       
 200e964:	b8 10 20 00 	clr  %i4                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200e968:	82 10 20 03 	mov  3, %g1                                    
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 200e96c:	c4 07 00 00 	ld  [ %i4 ], %g2                               
 200e970:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
  previous       = the_node->previous;                                
 200e974:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
        sc = rtems_bdbuf_execute_read_request (dd, bd, 1);            
        if (sc == RTEMS_SUCCESSFUL)                                   
        {                                                             
          rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
          rtems_chain_extract_unprotected (&bd->link);                
          rtems_bdbuf_group_obtain (bd);                              
 200e978:	90 10 00 1c 	mov  %i4, %o0                                  
  next->previous = previous;                                          
 200e97c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
 200e980:	7f ff f8 2b 	call  200ca2c <rtems_bdbuf_group_obtain>       
 200e984:	c4 20 40 00 	st  %g2, [ %g1 ]                               
                                                                      
static void                                                           
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,          
                                      rtems_blkdev_bnum  block)       
{                                                                     
  if (bdbuf_cache.read_ahead_task != 0                                
 200e988:	10 80 00 05 	b  200e99c <rtems_bdbuf_read+0x140>            
 200e98c:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
        {                                                             
          bd = NULL;                                                  
        }                                                             
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
 200e990:	7f ff f8 48 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200e994:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
                                                                      
static void                                                           
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,          
                                      rtems_blkdev_bnum  block)       
{                                                                     
  if (bdbuf_cache.read_ahead_task != 0                                
 200e998:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200e99c:	d0 00 62 d0 	ld  [ %g1 + 0x2d0 ], %o0	! 20216d0 <bdbuf_cache+0x84>
 200e9a0:	80 a2 20 00 	cmp  %o0, 0                                    
 200e9a4:	02 80 00 25 	be  200ea38 <rtems_bdbuf_read+0x1dc>           
 200e9a8:	01 00 00 00 	nop                                            
      && dd->read_ahead.trigger == block                              
 200e9ac:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
 200e9b0:	80 a0 40 19 	cmp  %g1, %i1                                  
 200e9b4:	12 80 00 21 	bne  200ea38 <rtems_bdbuf_read+0x1dc>          
 200e9b8:	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);            
 200e9bc:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        
 200e9c0:	80 a0 a0 00 	cmp  %g2, 0                                    
 200e9c4:	12 80 00 05 	bne  200e9d8 <rtems_bdbuf_read+0x17c>          <== NEVER TAKEN
 200e9c8:	82 10 20 00 	clr  %g1                                       
 200e9cc:	c2 07 60 68 	ld  [ %i5 + 0x68 ], %g1                        
 200e9d0:	80 a0 00 01 	cmp  %g0, %g1                                  
 200e9d4:	82 60 3f ff 	subx  %g0, -1, %g1                             
      && !rtems_bdbuf_is_read_ahead_active (dd))                      
 200e9d8:	80 a0 60 00 	cmp  %g1, 0                                    
 200e9dc:	02 80 00 17 	be  200ea38 <rtems_bdbuf_read+0x1dc>           <== NEVER TAKEN
 200e9e0:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
 200e9e4:	82 10 62 4c 	or  %g1, 0x24c, %g1	! 202164c <bdbuf_cache>    
  {                                                                   
    rtems_status_code sc;                                             
    rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;       
                                                                      
    if (rtems_chain_is_empty (chain))                                 
 200e9e8:	c4 00 60 88 	ld  [ %g1 + 0x88 ], %g2                        
 200e9ec:	82 00 60 8c 	add  %g1, 0x8c, %g1                            
 200e9f0:	80 a0 80 01 	cmp  %g2, %g1                                  
 200e9f4:	12 80 00 09 	bne  200ea18 <rtems_bdbuf_read+0x1bc>          <== NEVER TAKEN
 200e9f8:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    {                                                                 
      sc = rtems_event_send (bdbuf_cache.read_ahead_task,             
 200e9fc:	7f ff e7 12 	call  2008644 <rtems_event_send>               
 200ea00:	92 10 20 02 	mov  2, %o1                                    
                             RTEMS_BDBUF_READ_AHEAD_WAKE_UP);         
      if (sc != RTEMS_SUCCESSFUL)                                     
 200ea04:	80 a2 20 00 	cmp  %o0, 0                                    
 200ea08:	02 80 00 04 	be  200ea18 <rtems_bdbuf_read+0x1bc>           <== ALWAYS TAKEN
 200ea0c:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);             
 200ea10:	7f ff f8 11 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200ea14:	90 10 20 07 	mov  7, %o0                                    <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 200ea18:	82 10 62 4c 	or  %g1, 0x24c, %g1                            
 200ea1c:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2                        
    }                                                                 
                                                                      
    rtems_chain_append_unprotected (chain, &dd->read_ahead.node);     
 200ea20:	86 07 60 64 	add  %i5, 0x64, %g3                            
                                                                      
  the_node->next = tail;                                              
 200ea24:	88 00 60 8c 	add  %g1, 0x8c, %g4                            
  tail->previous = the_node;                                          
 200ea28:	c6 20 60 90 	st  %g3, [ %g1 + 0x90 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200ea2c:	c8 27 60 64 	st  %g4, [ %i5 + 0x64 ]                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 200ea30:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  the_node->previous = old_last;                                      
 200ea34:	c4 27 60 68 	st  %g2, [ %i5 + 0x68 ]                        
    }                                                                 
                                                                      
    rtems_bdbuf_check_read_ahead_trigger (dd, block);                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200ea38:	7f ff f8 2d 	call  200caec <rtems_bdbuf_unlock_cache>       
 200ea3c:	01 00 00 00 	nop                                            
                                                                      
  *bd_ptr = bd;                                                       
 200ea40:	f8 26 80 00 	st  %i4, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
 200ea44:	81 c7 e0 08 	ret                                            
 200ea48:	81 e8 00 00 	restore                                        
                                                                      

0200e2b0 <rtems_bdbuf_read_ahead_cancel>: */ RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain( const Chain_Node *node ) { return (node->next == NULL) && (node->previous == NULL);
 200e2b0:	c2 02 20 64 	ld  [ %o0 + 0x64 ], %g1                        
 200e2b4:	80 a0 60 00 	cmp  %g1, 0                                    
 200e2b8:	12 80 00 05 	bne  200e2cc <rtems_bdbuf_read_ahead_cancel+0x1c><== NEVER TAKEN
 200e2bc:	84 10 20 00 	clr  %g2                                       
 200e2c0:	c4 02 20 68 	ld  [ %o0 + 0x68 ], %g2                        
 200e2c4:	80 a0 00 02 	cmp  %g0, %g2                                  
 200e2c8:	84 60 3f ff 	subx  %g0, -1, %g2                             
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_read_ahead_cancel (rtems_disk_device *dd)                 
{                                                                     
  if (rtems_bdbuf_is_read_ahead_active (dd))                          
 200e2cc:	80 a0 a0 00 	cmp  %g2, 0                                    
 200e2d0:	12 80 00 07 	bne  200e2ec <rtems_bdbuf_read_ahead_cancel+0x3c><== ALWAYS TAKEN
 200e2d4:	01 00 00 00 	nop                                            
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200e2d8:	c4 02 20 68 	ld  [ %o0 + 0x68 ], %g2                        <== NOT EXECUTED
  next->previous = previous;                                          
 200e2dc:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
 200e2e0:	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;                                 
 200e2e4:	c0 22 20 68 	clr  [ %o0 + 0x68 ]                            <== NOT EXECUTED
 200e2e8:	c0 22 20 64 	clr  [ %o0 + 0x64 ]                            <== NOT EXECUTED
 200e2ec:	81 c3 e0 08 	retl                                           
                                                                      

0200e180 <rtems_bdbuf_read_ahead_task>: return sc; } static rtems_task rtems_bdbuf_read_ahead_task (rtems_task_argument arg) {
 200e180:	9d e3 bf a0 	save  %sp, -96, %sp                            
 200e184:	33 00 80 85 	sethi  %hi(0x2021400), %i1                     
  rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;         
                                                                      
  while (bdbuf_cache.read_ahead_enabled)                              
 200e188:	35 00 80 85 	sethi  %hi(0x2021400), %i2                     
 200e18c:	b2 16 62 d4 	or  %i1, 0x2d4, %i1                            
 200e190:	10 80 00 41 	b  200e294 <rtems_bdbuf_read_ahead_task+0x114> 
 200e194:	31 00 80 7a 	sethi  %hi(0x201e800), %i0                     
  {                                                                   
    rtems_chain_node *node;                                           
                                                                      
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);      
 200e198:	7f ff fa ac 	call  200cc48 <rtems_bdbuf_wait_for_event>     
 200e19c:	90 10 20 02 	mov  2, %o0                                    
    rtems_bdbuf_lock_cache ();                                        
 200e1a0:	7f ff fa 3e 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200e1a4:	01 00 00 00 	nop                                            
                                                                      
    while ((node = rtems_chain_get_unprotected (chain)) != NULL)      
 200e1a8:	30 80 00 34 	b,a   200e278 <rtems_bdbuf_read_ahead_task+0xf8>
                             rtems_blkdev_bnum        block,          
                             rtems_blkdev_bnum       *media_block_ptr)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (block < dd->block_count)                                        
 200e1ac:	c4 07 7f c4 	ld  [ %i5 + -60 ], %g2                         
    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;                  
      rtems_blkdev_bnum media_block = 0;                              
 200e1b0:	92 10 20 00 	clr  %o1                                       
                             rtems_blkdev_bnum        block,          
                             rtems_blkdev_bnum       *media_block_ptr)
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (block < dd->block_count)                                        
 200e1b4:	80 a7 00 02 	cmp  %i4, %g2                                  
 200e1b8:	1a 80 00 11 	bcc  200e1fc <rtems_bdbuf_read_ahead_task+0x7c>
 200e1bc:	82 10 20 04 	mov  4, %g1                                    
}                                                                     
                                                                      
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)                            
 200e1c0:	d2 07 7f cc 	ld  [ %i5 + -52 ], %o1                         
 200e1c4:	80 a2 60 00 	cmp  %o1, 0                                    
 200e1c8:	16 80 00 0a 	bge  200e1f0 <rtems_bdbuf_read_ahead_task+0x70><== ALWAYS TAKEN
 200e1cc:	93 2f 00 09 	sll  %i4, %o1, %o1                             
    /*                                                                
     * 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); 
 200e1d0:	d2 07 7f c0 	ld  [ %i5 + -64 ], %o1                         <== NOT EXECUTED
 200e1d4:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 200e1d8:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
 200e1dc:	40 00 3a c2 	call  201cce4 <__muldi3>                       <== NOT EXECUTED
 200e1e0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 200e1e4:	d6 07 7f bc 	ld  [ %i5 + -68 ], %o3                         <== NOT EXECUTED
 200e1e8:	40 00 3c d0 	call  201d528 <__udivdi3>                      <== NOT EXECUTED
 200e1ec:	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;
 200e1f0:	c2 07 7f b4 	ld  [ %i5 + -76 ], %g1                         
 200e1f4:	92 02 40 01 	add  %o1, %g1, %o1                             
 200e1f8:	82 10 20 00 	clr  %g1                                       
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
 200e1fc:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
      rtems_status_code sc =                                          
        rtems_bdbuf_get_media_block (dd, block, &media_block);        
                                                                      
      rtems_chain_set_off_chain (&dd->read_ahead.node);               
                                                                      
      if (sc == RTEMS_SUCCESSFUL)                                     
 200e200:	80 a0 60 00 	cmp  %g1, 0                                    
 200e204:	12 80 00 1b 	bne  200e270 <rtems_bdbuf_read_ahead_task+0xf0>
 200e208:	c0 27 40 00 	clr  [ %i5 ]                                   
    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 *)                   
 200e20c:	b6 07 7f 9c 	add  %i5, -100, %i3                            
                                                                      
      rtems_chain_set_off_chain (&dd->read_ahead.node);               
                                                                      
      if (sc == RTEMS_SUCCESSFUL)                                     
      {                                                               
        rtems_bdbuf_buffer *bd =                                      
 200e210:	7f ff fd 12 	call  200d658 <rtems_bdbuf_get_buffer_for_read_ahead>
 200e214:	90 10 00 1b 	mov  %i3, %o0                                  
          rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);    
                                                                      
        if (bd != NULL)                                               
 200e218:	92 92 20 00 	orcc  %o0, 0, %o1                              
 200e21c:	02 80 00 17 	be  200e278 <rtems_bdbuf_read_ahead_task+0xf8> <== NEVER TAKEN
 200e220:	c2 06 23 f8 	ld  [ %i0 + 0x3f8 ], %g1                       
        {                                                             
          uint32_t transfer_count = dd->block_count - block;          
 200e224:	d4 07 7f c4 	ld  [ %i5 + -60 ], %o2                         
 200e228:	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)                   
 200e22c:	80 a2 80 01 	cmp  %o2, %g1                                  
 200e230:	2a 80 00 09 	bcs,a   200e254 <rtems_bdbuf_read_ahead_task+0xd4>
 200e234:	82 10 3f ff 	mov  -1, %g1                                   
          {                                                           
            transfer_count = max_transfer_count;                      
            dd->read_ahead.trigger = block + transfer_count / 2;      
 200e238:	85 30 60 01 	srl  %g1, 1, %g2                               
            dd->read_ahead.next = block + transfer_count;             
 200e23c:	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;      
 200e240:	84 00 80 1c 	add  %g2, %i4, %g2                             
            dd->read_ahead.next = block + transfer_count;             
 200e244:	b8 00 40 1c 	add  %g1, %i4, %i4                             
          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;      
 200e248:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
            dd->read_ahead.next = block + transfer_count;             
 200e24c:	10 80 00 03 	b  200e258 <rtems_bdbuf_read_ahead_task+0xd8>  
 200e250:	f8 27 60 0c 	st  %i4, [ %i5 + 0xc ]                         
          }                                                           
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
 200e254:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
          }                                                           
                                                                      
          ++dd->stats.read_ahead_transfers;                           
 200e258:	c2 07 7f e8 	ld  [ %i5 + -24 ], %g1                         
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
 200e25c:	90 10 00 1b 	mov  %i3, %o0                                  
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
          }                                                           
                                                                      
          ++dd->stats.read_ahead_transfers;                           
 200e260:	82 00 60 01 	inc  %g1                                       
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
 200e264:	7f ff ff 94 	call  200e0b4 <rtems_bdbuf_execute_read_request>
 200e268:	c2 27 7f e8 	st  %g1, [ %i5 + -24 ]                         
 200e26c:	30 80 00 03 	b,a   200e278 <rtems_bdbuf_read_ahead_task+0xf8>
        }                                                             
      }                                                               
      else                                                            
      {                                                               
        dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;    
 200e270:	82 10 3f ff 	mov  -1, %g1                                   
 200e274:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
 200e278:	7f ff f9 e3 	call  200ca04 <_Chain_Get_unprotected>         
 200e27c:	90 10 00 19 	mov  %i1, %o0                                  
    rtems_chain_node *node;                                           
                                                                      
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);      
    rtems_bdbuf_lock_cache ();                                        
                                                                      
    while ((node = rtems_chain_get_unprotected (chain)) != NULL)      
 200e280:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200e284:	32 bf ff ca 	bne,a   200e1ac <rtems_bdbuf_read_ahead_task+0x2c>
 200e288:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
      {                                                               
        dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;    
      }                                                               
    }                                                                 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
 200e28c:	7f ff fa 18 	call  200caec <rtems_bdbuf_unlock_cache>       
 200e290:	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)                              
 200e294:	82 16 a2 4c 	or  %i2, 0x24c, %g1                            
 200e298:	c2 08 60 94 	ldub  [ %g1 + 0x94 ], %g1                      
 200e29c:	80 a0 60 00 	cmp  %g1, 0                                    
 200e2a0:	12 bf ff be 	bne  200e198 <rtems_bdbuf_read_ahead_task+0x18><== ALWAYS TAKEN
 200e2a4:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
  }                                                                   
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
 200e2a8:	7f ff ea e9 	call  2008e4c <rtems_task_delete>              <== NOT EXECUTED
 200e2ac:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

0200ea4c <rtems_bdbuf_release>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_bdbuf_release (rtems_bdbuf_buffer *bd) {
 200ea4c:	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)                                                     
 200ea50:	80 a6 20 00 	cmp  %i0, 0                                    
 200ea54:	02 80 00 31 	be  200eb18 <rtems_bdbuf_release+0xcc>         <== NEVER TAKEN
 200ea58:	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();                                           
 200ea5c:	7f ff f8 0f 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200ea60:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");           
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
 200ea64:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
 200ea68:	80 a2 20 04 	cmp  %o0, 4                                    
 200ea6c:	02 80 00 22 	be  200eaf4 <rtems_bdbuf_release+0xa8>         
 200ea70:	01 00 00 00 	nop                                            
 200ea74:	18 80 00 06 	bgu  200ea8c <rtems_bdbuf_release+0x40>        
 200ea78:	80 a2 20 06 	cmp  %o0, 6                                    
 200ea7c:	80 a2 20 03 	cmp  %o0, 3                                    
 200ea80:	12 80 00 20 	bne  200eb00 <rtems_bdbuf_release+0xb4>        <== NEVER TAKEN
 200ea84:	01 00 00 00 	nop                                            
 200ea88:	30 80 00 04 	b,a   200ea98 <rtems_bdbuf_release+0x4c>       
 200ea8c:	18 80 00 1d 	bgu  200eb00 <rtems_bdbuf_release+0xb4>        <== NEVER TAKEN
 200ea90:	01 00 00 00 	nop                                            
 200ea94:	30 80 00 15 	b,a   200eae8 <rtems_bdbuf_release+0x9c>       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)     
{                                                                     
  rtems_bdbuf_group_release (bd);                                     
 200ea98:	7f ff f7 ea 	call  200ca40 <rtems_bdbuf_group_release>      
 200ea9c:	90 10 00 18 	mov  %i0, %o0                                  
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200eaa0:	82 10 20 02 	mov  2, %g1                                    
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 200eaa4:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
 200eaa8:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
 200eaac:	90 12 22 4c 	or  %o0, 0x24c, %o0                            
 200eab0:	c2 02 20 48 	ld  [ %o0 + 0x48 ], %g1                        
                                                                      
  the_node->next = tail;                                              
 200eab4:	84 02 20 44 	add  %o0, 0x44, %g2                            
  tail->previous = the_node;                                          
 200eab8:	f0 22 20 48 	st  %i0, [ %o0 + 0x48 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200eabc:	c4 26 00 00 	st  %g2, [ %i0 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 200eac0:	f0 20 40 00 	st  %i0, [ %g1 ]                               
  the_node->previous = old_last;                                      
 200eac4:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
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)                                                    
 200eac8:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 200eacc:	80 a0 60 00 	cmp  %g1, 0                                    
 200ead0:	22 80 00 03 	be,a   200eadc <rtems_bdbuf_release+0x90>      
 200ead4:	90 02 20 74 	add  %o0, 0x74, %o0                            
 200ead8:	90 02 20 64 	add  %o0, 0x64, %o0                            
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else                                                                
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
 200eadc:	7f ff f8 98 	call  200cd3c <rtems_bdbuf_wake>               
 200eae0:	01 00 00 00 	nop                                            
 200eae4:	30 80 00 09 	b,a   200eb08 <rtems_bdbuf_release+0xbc>       
    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);                   
 200eae8:	7f ff fe 03 	call  200e2f4 <rtems_bdbuf_discard_buffer_after_access>
 200eaec:	90 10 00 18 	mov  %i0, %o0                                  
      break;                                                          
 200eaf0:	30 80 00 06 	b,a   200eb08 <rtems_bdbuf_release+0xbc>       
    case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);             
 200eaf4:	7f ff f9 a6 	call  200d18c <rtems_bdbuf_add_to_modified_list_after_access>
 200eaf8:	90 10 00 18 	mov  %i0, %o0                                  
      break;                                                          
 200eafc:	30 80 00 03 	b,a   200eb08 <rtems_bdbuf_release+0xbc>       
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);
 200eb00:	7f ff f7 ec 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200eb04:	92 10 20 0e 	mov  0xe, %o1                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200eb08:	7f ff f7 f9 	call  200caec <rtems_bdbuf_unlock_cache>       
 200eb0c:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200eb10:	81 c7 e0 08 	ret                                            
 200eb14:	81 e8 00 00 	restore                                        
}                                                                     
 200eb18:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200eb1c:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      

0200eb20 <rtems_bdbuf_release_modified>: rtems_status_code rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd) {
 200eb20:	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)                                                     
 200eb24:	80 a6 20 00 	cmp  %i0, 0                                    
 200eb28:	02 80 00 19 	be  200eb8c <rtems_bdbuf_release_modified+0x6c><== NEVER TAKEN
 200eb2c:	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();                                           
 200eb30:	7f ff f7 da 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200eb34:	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)                                                  
 200eb38:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
 200eb3c:	80 a2 20 03 	cmp  %o0, 3                                    
 200eb40:	0a 80 00 0d 	bcs  200eb74 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
 200eb44:	80 a2 20 05 	cmp  %o0, 5                                    
 200eb48:	08 80 00 05 	bleu  200eb5c <rtems_bdbuf_release_modified+0x3c>
 200eb4c:	80 a2 20 06 	cmp  %o0, 6                                    
 200eb50:	12 80 00 09 	bne  200eb74 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
 200eb54:	01 00 00 00 	nop                                            
 200eb58:	30 80 00 04 	b,a   200eb68 <rtems_bdbuf_release_modified+0x48>
  {                                                                   
    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);             
 200eb5c:	7f ff f9 8c 	call  200d18c <rtems_bdbuf_add_to_modified_list_after_access>
 200eb60:	90 10 00 18 	mov  %i0, %o0                                  
      break;                                                          
 200eb64:	30 80 00 06 	b,a   200eb7c <rtems_bdbuf_release_modified+0x5c>
    case RTEMS_BDBUF_STATE_ACCESS_PURGED:                             
      rtems_bdbuf_discard_buffer_after_access (bd);                   
 200eb68:	7f ff fd e3 	call  200e2f4 <rtems_bdbuf_discard_buffer_after_access>
 200eb6c:	90 10 00 18 	mov  %i0, %o0                                  
      break;                                                          
 200eb70:	30 80 00 03 	b,a   200eb7c <rtems_bdbuf_release_modified+0x5c>
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);
 200eb74:	7f ff f7 cf 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200eb78:	92 10 20 12 	mov  0x12, %o1                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200eb7c:	7f ff f7 dc 	call  200caec <rtems_bdbuf_unlock_cache>       
 200eb80:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200eb84:	81 c7 e0 08 	ret                                            
 200eb88:	81 e8 00 00 	restore                                        
}                                                                     
 200eb8c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200eb90:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      

0200cdd0 <rtems_bdbuf_remove_from_tree>: return bdbuf_cache.buffer_waiters.count; } static void rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd) {
 200cdd0:	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;                                     
 200cdd4:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 */                                                                   
static int                                                            
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer**      root,                
                       const rtems_bdbuf_buffer* node)                
{                                                                     
  const rtems_disk_device *dd = node->dd;                             
 200cdd8:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4                        
  rtems_blkdev_bnum block = node->block;                              
 200cddc:	f6 06 20 18 	ld  [ %i0 + 0x18 ], %i3                        
                                                                      
  rtems_bdbuf_buffer*  p = *root;                                     
 200cde0:	fa 00 62 88 	ld  [ %g1 + 0x288 ], %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));                           
 200cde4:	90 07 bf 80 	add  %fp, -128, %o0                            
 200cde8:	92 10 20 00 	clr  %o1                                       
 200cdec:	40 00 1d 8f 	call  2014428 <memset>                         
 200cdf0:	94 10 20 80 	mov  0x80, %o2                                 
  rtems_bdbuf_buffer*  r;                                             
  rtems_bdbuf_buffer*  s;                                             
  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;                          
 200cdf4:	86 07 bf 80 	add  %fp, -128, %g3                            
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
        || ((p->dd == dd) && (p->block < block)))                     
    {                                                                 
      p->avl.cache = 1;                                               
 200cdf8:	84 10 20 01 	mov  1, %g2                                    
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
 200cdfc:	10 80 00 15 	b  200ce50 <rtems_bdbuf_remove_from_tree+0x80> 
 200ce00:	b4 10 3f ff 	mov  -1, %i2                                   
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
 200ce04:	fa 20 c0 00 	st  %i5, [ %g3 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
 200ce08:	80 a0 40 1c 	cmp  %g1, %i4                                  
 200ce0c:	0a 80 00 09 	bcs  200ce30 <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
 200ce10:	88 00 e0 04 	add  %g3, 4, %g4                               
        || ((p->dd == dd) && (p->block < block)))                     
 200ce14:	80 a0 40 1c 	cmp  %g1, %i4                                  
 200ce18:	32 80 00 0c 	bne,a   200ce48 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
 200ce1c:	f4 2f 60 10 	stb  %i2, [ %i5 + 0x10 ]                       <== NOT EXECUTED
 200ce20:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
 200ce24:	80 a0 40 1b 	cmp  %g1, %i3                                  
 200ce28:	1a 80 00 05 	bcc  200ce3c <rtems_bdbuf_remove_from_tree+0x6c>
 200ce2c:	01 00 00 00 	nop                                            
    {                                                                 
      p->avl.cache = 1;                                               
 200ce30:	c4 2f 60 10 	stb  %g2, [ %i5 + 0x10 ]                       
      p = p->avl.right;                                               
 200ce34:	10 80 00 06 	b  200ce4c <rtems_bdbuf_remove_from_tree+0x7c> 
 200ce38:	fa 07 60 0c 	ld  [ %i5 + 0xc ], %i5                         
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
 200ce3c:	02 80 00 b9 	be  200d120 <rtems_bdbuf_remove_from_tree+0x350>
 200ce40:	82 07 bf 80 	add  %fp, -128, %g1                            
    {                                                                 
      p->avl.cache = -1;                                              
 200ce44:	f4 2f 60 10 	stb  %i2, [ %i5 + 0x10 ]                       
      p = p->avl.left;                                                
 200ce48:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
 200ce4c:	86 10 00 04 	mov  %g4, %g3                                  
                                                                      
  bool modified = false;                                              
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
 200ce50:	80 a7 60 00 	cmp  %i5, 0                                    
 200ce54:	32 bf ff ec 	bne,a   200ce04 <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
 200ce58:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
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);
 200ce5c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        <== NOT EXECUTED
 200ce60:	7f ff ff 14 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200ce64:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
  {                                                                   
    p = NULL;                                                         
  }                                                                   
                                                                      
  /* at this moment q - is a node to delete, p is q's parent */       
  if (q->avl.right == NULL)                                           
 200ce68:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 200ce6c:	80 a0 60 00 	cmp  %g1, 0                                    
 200ce70:	32 80 00 08 	bne,a   200ce90 <rtems_bdbuf_remove_from_tree+0xc0>
 200ce74:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
  {                                                                   
    r = q->avl.left;                                                  
 200ce78:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    if (r != NULL)                                                    
 200ce7c:	80 a0 60 00 	cmp  %g1, 0                                    
 200ce80:	32 80 00 27 	bne,a   200cf1c <rtems_bdbuf_remove_from_tree+0x14c>
 200ce84:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
                                                                      
      *t = q = s;                                                     
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
 200ce88:	10 80 00 26 	b  200cf20 <rtems_bdbuf_remove_from_tree+0x150>
 200ce8c:	80 a7 20 00 	cmp  %i4, 0                                    
  {                                                                   
    rtems_bdbuf_buffer **t;                                           
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
 200ce90:	80 a0 a0 00 	cmp  %g2, 0                                    
 200ce94:	02 80 00 06 	be  200ceac <rtems_bdbuf_remove_from_tree+0xdc>
 200ce98:	84 10 00 01 	mov  %g1, %g2                                  
 200ce9c:	b6 10 00 01 	mov  %g1, %i3                                  
 200cea0:	86 10 00 04 	mov  %g4, %g3                                  
                                                                      
      while (s->avl.left != NULL)                                     
      {                                                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
 200cea4:	10 80 00 0f 	b  200cee0 <rtems_bdbuf_remove_from_tree+0x110>
 200cea8:	b2 10 3f ff 	mov  -1, %i1                                   
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
 200ceac:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
      r->avl.bal = q->avl.bal;                                        
      r->avl.cache = 1;                                               
      *buf_prev++ = q = r;                                            
 200ceb0:	c2 21 3f fc 	st  %g1, [ %g4 + -4 ]                          
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
 200ceb4:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
      r->avl.bal = q->avl.bal;                                        
 200ceb8:	c4 0f 60 11 	ldub  [ %i5 + 0x11 ], %g2                      
      r->avl.cache = 1;                                               
      *buf_prev++ = q = r;                                            
 200cebc:	86 10 00 04 	mov  %g4, %g3                                  
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
      r->avl.bal = q->avl.bal;                                        
 200cec0:	c4 28 60 11 	stb  %g2, [ %g1 + 0x11 ]                       
      r->avl.cache = 1;                                               
 200cec4:	84 10 20 01 	mov  1, %g2                                    
 200cec8:	10 80 00 15 	b  200cf1c <rtems_bdbuf_remove_from_tree+0x14c>
 200cecc:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       
                                                                      
      while (s->avl.left != NULL)                                     
      {                                                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
 200ced0:	f2 28 a0 10 	stb  %i1, [ %g2 + 0x10 ]                       
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
      {                                                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
 200ced4:	b6 10 00 02 	mov  %g2, %i3                                  
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
      {                                                               
        *buf_prev++ = r = s;                                          
 200ced8:	86 00 e0 04 	add  %g3, 4, %g3                               
        s = r->avl.left;                                              
 200cedc:	84 10 00 1a 	mov  %i2, %g2                                  
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
 200cee0:	f4 00 a0 08 	ld  [ %g2 + 8 ], %i2                           
 200cee4:	80 a6 a0 00 	cmp  %i2, 0                                    
 200cee8:	32 bf ff fa 	bne,a   200ced0 <rtems_bdbuf_remove_from_tree+0x100>
 200ceec:	c4 20 c0 00 	st  %g2, [ %g3 ]                               
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
 200cef0:	f4 07 60 08 	ld  [ %i5 + 8 ], %i2                           
      r->avl.left = s->avl.right;                                     
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
      s->avl.cache = 1;                                               
                                                                      
      *t = q = s;                                                     
 200cef4:	c4 21 3f fc 	st  %g2, [ %g4 + -4 ]                          
        *buf_prev++ = r = s;                                          
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
 200cef8:	f4 20 a0 08 	st  %i2, [ %g2 + 8 ]                           
      r->avl.left = s->avl.right;                                     
 200cefc:	f4 00 a0 0c 	ld  [ %g2 + 0xc ], %i2                         
      s->avl.right = q->avl.right;                                    
 200cf00:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
      s->avl.bal = q->avl.bal;                                        
 200cf04:	c2 0f 60 11 	ldub  [ %i5 + 0x11 ], %g1                      
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
      }                                                               
                                                                      
      s->avl.left = q->avl.left;                                      
      r->avl.left = s->avl.right;                                     
 200cf08:	f4 26 e0 08 	st  %i2, [ %i3 + 8 ]                           
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
 200cf0c:	c2 28 a0 11 	stb  %g1, [ %g2 + 0x11 ]                       
      s->avl.cache = 1;                                               
 200cf10:	82 10 20 01 	mov  1, %g1                                    
 200cf14:	c2 28 a0 10 	stb  %g1, [ %g2 + 0x10 ]                       
                                                                      
      *t = q = s;                                                     
 200cf18:	82 10 00 02 	mov  %g2, %g1                                  
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
 200cf1c:	80 a7 20 00 	cmp  %i4, 0                                    
 200cf20:	02 80 00 0d 	be  200cf54 <rtems_bdbuf_remove_from_tree+0x184>
 200cf24:	05 00 80 85 	sethi  %hi(0x2021400), %g2                     
  {                                                                   
    if (p->avl.cache == -1)                                           
 200cf28:	c4 4f 20 10 	ldsb  [ %i4 + 0x10 ], %g2                      
 200cf2c:	80 a0 bf ff 	cmp  %g2, -1                                   
 200cf30:	32 80 00 03 	bne,a   200cf3c <rtems_bdbuf_remove_from_tree+0x16c>
 200cf34:	c2 27 20 0c 	st  %g1, [ %i4 + 0xc ]                         
    {                                                                 
      p->avl.left = q;                                                
 200cf38:	c2 27 20 08 	st  %g1, [ %i4 + 8 ]                           
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
 200cf3c:	82 07 bf 80 	add  %fp, -128, %g1                            
 200cf40:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200cf44:	18 80 00 06 	bgu  200cf5c <rtems_bdbuf_remove_from_tree+0x18c>
 200cf48:	ba 10 20 01 	mov  1, %i5                                    
 200cf4c:	81 c7 e0 08 	ret                                            
 200cf50:	81 e8 00 00 	restore                                        
      p->avl.right = q;                                               
    }                                                                 
  }                                                                   
  else                                                                
  {                                                                   
    *root = q;                                                        
 200cf54:	10 bf ff fa 	b  200cf3c <rtems_bdbuf_remove_from_tree+0x16c>
 200cf58:	c2 20 a2 88 	st  %g1, [ %g2 + 0x288 ]                       
        case +1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
                                                                      
        case  0:                                                      
          p->avl.bal = -1;                                            
 200cf5c:	b6 10 3f ff 	mov  -1, %i3                                   
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
 200cf60:	b2 10 00 01 	mov  %g1, %i1                                  
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
    {                                                                 
      p = *--buf_prev;                                                
 200cf64:	c2 00 ff fc 	ld  [ %g3 + -4 ], %g1                          
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
 200cf68:	f8 48 60 10 	ldsb  [ %g1 + 0x10 ], %i4                      
 200cf6c:	c4 08 60 11 	ldub  [ %g1 + 0x11 ], %g2                      
 200cf70:	80 a7 3f ff 	cmp  %i4, -1                                   
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
 200cf74:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
 200cf78:	12 80 00 2a 	bne  200d020 <rtems_bdbuf_remove_from_tree+0x250>
 200cf7c:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
 200cf80:	80 a0 a0 00 	cmp  %g2, 0                                    
 200cf84:	22 80 00 14 	be,a   200cfd4 <rtems_bdbuf_remove_from_tree+0x204>
 200cf88:	fa 28 60 11 	stb  %i5, [ %g1 + 0x11 ]                       
 200cf8c:	80 a0 a0 01 	cmp  %g2, 1                                    
 200cf90:	02 80 00 06 	be  200cfa8 <rtems_bdbuf_remove_from_tree+0x1d8>
 200cf94:	80 a0 bf ff 	cmp  %g2, -1                                   
 200cf98:	12 80 00 4f 	bne  200d0d4 <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
 200cf9c:	84 10 20 01 	mov  1, %g2                                    
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
      {                                                               
        case +1:                                                      
          p->avl.bal = 0;                                             
 200cfa0:	10 80 00 4d 	b  200d0d4 <rtems_bdbuf_remove_from_tree+0x304>
 200cfa4:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
          p->avl.bal = 1;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case +1:                                                      
          p1 = p->avl.right;                                          
 200cfa8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
                                                                      
          if (p1->avl.bal >= 0) /* simple RR-turn */                  
 200cfac:	f4 48 a0 11 	ldsb  [ %g2 + 0x11 ], %i2                      
 200cfb0:	80 a6 a0 00 	cmp  %i2, 0                                    
 200cfb4:	06 80 00 0a 	bl  200cfdc <rtems_bdbuf_remove_from_tree+0x20c>
 200cfb8:	c8 00 a0 08 	ld  [ %g2 + 8 ], %g4                           
          {                                                           
            p->avl.right = p1->avl.left;                              
 200cfbc:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
            p1->avl.left = p;                                         
                                                                      
            if (p1->avl.bal == 0)                                     
 200cfc0:	80 a6 a0 00 	cmp  %i2, 0                                    
 200cfc4:	12 80 00 2d 	bne  200d078 <rtems_bdbuf_remove_from_tree+0x2a8>
 200cfc8:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
            {                                                         
              p1->avl.bal = -1;                                       
 200cfcc:	f8 28 a0 11 	stb  %i4, [ %g2 + 0x11 ]                       
 200cfd0:	82 10 00 02 	mov  %g2, %g1                                  
              modified = false;                                       
 200cfd4:	10 80 00 40 	b  200d0d4 <rtems_bdbuf_remove_from_tree+0x304>
 200cfd8:	84 10 20 00 	clr  %g2                                       
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
 200cfdc:	f4 01 20 0c 	ld  [ %g4 + 0xc ], %i2                         
            p2->avl.right = p1;                                       
 200cfe0:	c4 21 20 0c 	st  %g2, [ %g4 + 0xc ]                         
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
 200cfe4:	f4 20 a0 08 	st  %i2, [ %g2 + 8 ]                           
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
 200cfe8:	f4 01 20 08 	ld  [ %g4 + 8 ], %i2                           
            p2->avl.left = p;                                         
 200cfec:	c2 21 20 08 	st  %g1, [ %g4 + 8 ]                           
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
 200cff0:	f4 20 60 0c 	st  %i2, [ %g1 + 0xc ]                         
            p2->avl.left = p;                                         
                                                                      
            if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
 200cff4:	f4 49 20 11 	ldsb  [ %g4 + 0x11 ], %i2                      
 200cff8:	80 a6 a0 01 	cmp  %i2, 1                                    
 200cffc:	32 80 00 03 	bne,a   200d008 <rtems_bdbuf_remove_from_tree+0x238>
 200d000:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
 200d004:	f8 28 60 11 	stb  %i4, [ %g1 + 0x11 ]                       
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
 200d008:	c2 49 20 11 	ldsb  [ %g4 + 0x11 ], %g1                      
 200d00c:	80 a0 7f ff 	cmp  %g1, -1                                   
 200d010:	32 80 00 2e 	bne,a   200d0c8 <rtems_bdbuf_remove_from_tree+0x2f8><== ALWAYS TAKEN
 200d014:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
 200d018:	10 80 00 2c 	b  200d0c8 <rtems_bdbuf_remove_from_tree+0x2f8><== NOT EXECUTED
 200d01c:	fa 28 a0 11 	stb  %i5, [ %g2 + 0x11 ]                       <== NOT EXECUTED
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
 200d020:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d024:	22 bf ff ec 	be,a   200cfd4 <rtems_bdbuf_remove_from_tree+0x204>
 200d028:	f6 28 60 11 	stb  %i3, [ %g1 + 0x11 ]                       
 200d02c:	80 a0 a0 01 	cmp  %g2, 1                                    
 200d030:	02 80 00 06 	be  200d048 <rtems_bdbuf_remove_from_tree+0x278>
 200d034:	80 a0 bf ff 	cmp  %g2, -1                                   
 200d038:	32 80 00 27 	bne,a   200d0d4 <rtems_bdbuf_remove_from_tree+0x304><== NEVER TAKEN
 200d03c:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
          p->avl.bal = -1;                                            
          modified = false;                                           
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
 200d040:	10 80 00 04 	b  200d050 <rtems_bdbuf_remove_from_tree+0x280>
 200d044:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
      {                                                               
        case +1:                                                      
          p->avl.bal = 0;                                             
 200d048:	10 80 00 22 	b  200d0d0 <rtems_bdbuf_remove_from_tree+0x300>
 200d04c:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
                                                                      
          if (p1->avl.bal <= 0) /* simple LL-turn */                  
 200d050:	f8 48 a0 11 	ldsb  [ %g2 + 0x11 ], %i4                      
 200d054:	80 a7 20 00 	cmp  %i4, 0                                    
 200d058:	14 80 00 0c 	bg  200d088 <rtems_bdbuf_remove_from_tree+0x2b8>
 200d05c:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
          {                                                           
            p->avl.left = p1->avl.right;                              
 200d060:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
            p1->avl.right = p;                                        
            if (p1->avl.bal == 0)                                     
 200d064:	80 a7 20 00 	cmp  %i4, 0                                    
 200d068:	12 80 00 04 	bne  200d078 <rtems_bdbuf_remove_from_tree+0x2a8>
 200d06c:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
            {                                                         
              p1->avl.bal = 1;                                        
 200d070:	10 bf ff d8 	b  200cfd0 <rtems_bdbuf_remove_from_tree+0x200>
 200d074:	fa 28 a0 11 	stb  %i5, [ %g2 + 0x11 ]                       
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
 200d078:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
              p1->avl.bal = 0;                                        
 200d07c:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
 200d080:	10 80 00 14 	b  200d0d0 <rtems_bdbuf_remove_from_tree+0x300>
 200d084:	82 10 00 02 	mov  %g2, %g1                                  
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
 200d088:	f8 01 20 08 	ld  [ %g4 + 8 ], %i4                           
            p2->avl.left = p1;                                        
 200d08c:	c4 21 20 08 	st  %g2, [ %g4 + 8 ]                           
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
 200d090:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
 200d094:	f8 01 20 0c 	ld  [ %g4 + 0xc ], %i4                         
            p2->avl.right = p;                                        
 200d098:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
 200d09c:	f8 20 60 08 	st  %i4, [ %g1 + 8 ]                           
            p2->avl.right = p;                                        
                                                                      
            if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
 200d0a0:	f8 49 20 11 	ldsb  [ %g4 + 0x11 ], %i4                      
 200d0a4:	80 a7 3f ff 	cmp  %i4, -1                                   
 200d0a8:	32 80 00 03 	bne,a   200d0b4 <rtems_bdbuf_remove_from_tree+0x2e4>
 200d0ac:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
 200d0b0:	fa 28 60 11 	stb  %i5, [ %g1 + 0x11 ]                       
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
 200d0b4:	c2 49 20 11 	ldsb  [ %g4 + 0x11 ], %g1                      
 200d0b8:	80 a0 60 01 	cmp  %g1, 1                                    
 200d0bc:	32 80 00 03 	bne,a   200d0c8 <rtems_bdbuf_remove_from_tree+0x2f8>
 200d0c0:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
 200d0c4:	f6 28 a0 11 	stb  %i3, [ %g2 + 0x11 ]                       
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
 200d0c8:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
 200d0cc:	82 10 00 04 	mov  %g4, %g1                                  
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
 200d0d0:	84 10 20 01 	mov  1, %g2                                    
{                                                                     
  return bdbuf_cache.buffer_waiters.count;                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)                 
 200d0d4:	88 00 ff fc 	add  %g3, -4, %g4                              
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
 200d0d8:	80 a1 00 19 	cmp  %g4, %i1                                  
 200d0dc:	28 80 00 09 	bleu,a   200d100 <rtems_bdbuf_remove_from_tree+0x330>
 200d0e0:	05 00 80 85 	sethi  %hi(0x2021400), %g2                     
    {                                                                 
      q = *(buf_prev - 1);                                            
 200d0e4:	c8 00 ff f8 	ld  [ %g3 + -8 ], %g4                          
                                                                      
      if (q->avl.cache == -1)                                         
 200d0e8:	f8 49 20 10 	ldsb  [ %g4 + 0x10 ], %i4                      
 200d0ec:	80 a7 3f ff 	cmp  %i4, -1                                   
 200d0f0:	32 80 00 07 	bne,a   200d10c <rtems_bdbuf_remove_from_tree+0x33c>
 200d0f4:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
      {                                                               
        q->avl.left = p;                                              
 200d0f8:	10 80 00 05 	b  200d10c <rtems_bdbuf_remove_from_tree+0x33c>
 200d0fc:	c2 21 20 08 	st  %g1, [ %g4 + 8 ]                           
        q->avl.right = p;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
 200d100:	c2 20 a2 88 	st  %g1, [ %g2 + 0x288 ]                       
 200d104:	81 c7 e0 08 	ret                                            
 200d108:	81 e8 00 00 	restore                                        
    *root = q;                                                        
  }                                                                   
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
 200d10c:	80 88 a0 ff 	btst  0xff, %g2                                
 200d110:	12 bf ff 95 	bne  200cf64 <rtems_bdbuf_remove_from_tree+0x194>
 200d114:	86 00 ff fc 	add  %g3, -4, %g3                              
 200d118:	81 c7 e0 08 	ret                                            
 200d11c:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  q = p;                                                              
                                                                      
  buf_prev--;                                                         
  if (buf_prev > buf_stack)                                           
 200d120:	80 a0 c0 01 	cmp  %g3, %g1                                  
 200d124:	08 bf ff 51 	bleu  200ce68 <rtems_bdbuf_remove_from_tree+0x98>
 200d128:	b8 10 20 00 	clr  %i4                                       
  {                                                                   
    p = *(buf_prev - 1);                                              
 200d12c:	10 bf ff 4f 	b  200ce68 <rtems_bdbuf_remove_from_tree+0x98> 
 200d130:	f8 01 3f f8 	ld  [ %g4 + -8 ], %i4                          
                                                                      

0200d268 <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) {
 200d268:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch (bd->state)                                                  
 200d26c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
 200d270:	80 a2 20 00 	cmp  %o0, 0                                    
 200d274:	22 80 00 0b 	be,a   200d2a0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
 200d278:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 200d27c:	80 a2 20 02 	cmp  %o0, 2                                    
 200d280:	12 80 00 06 	bne  200d298 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30><== NEVER TAKEN
 200d284:	01 00 00 00 	nop                                            
  {                                                                   
    case RTEMS_BDBUF_STATE_FREE:                                      
      break;                                                          
    case RTEMS_BDBUF_STATE_CACHED:                                    
      rtems_bdbuf_remove_from_tree (bd);                              
 200d288:	7f ff fe d2 	call  200cdd0 <rtems_bdbuf_remove_from_tree>   
 200d28c:	90 10 00 18 	mov  %i0, %o0                                  
      break;                                                          
 200d290:	10 80 00 04 	b  200d2a0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
 200d294:	c4 06 00 00 	ld  [ %i0 ], %g2                               
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_10);
 200d298:	7f ff fe 06 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200d29c:	92 10 20 16 	mov  0x16, %o1                                 <== NOT EXECUTED
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200d2a0:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
  next->previous = previous;                                          
 200d2a4:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 200d2a8:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 200d2ac:	81 c7 e0 08 	ret                                            
 200d2b0:	81 e8 00 00 	restore                                        
                                                                      

0200cb68 <rtems_bdbuf_restore_preemption>: static void rtems_bdbuf_restore_preemption (rtems_mode prev_mode) {
 200cb68:	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); 
 200cb6c:	13 00 00 3f 	sethi  %hi(0xfc00), %o1                        
  return prev_mode;                                                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)                 
{                                                                     
 200cb70:	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); 
 200cb74:	90 10 00 18 	mov  %i0, %o0                                  
 200cb78:	92 12 63 ff 	or  %o1, 0x3ff, %o1                            
 200cb7c:	40 00 11 60 	call  20110fc <rtems_task_mode>                
 200cb80:	94 07 a0 44 	add  %fp, 0x44, %o2                            
  if (sc != RTEMS_SUCCESSFUL)                                         
 200cb84:	80 a2 20 00 	cmp  %o0, 0                                    
 200cb88:	02 80 00 04 	be  200cb98 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
 200cb8c:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);                
 200cb90:	7f ff ff b1 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cb94:	90 10 20 06 	mov  6, %o0	! 6 <PROM_START+0x6>               <== NOT EXECUTED
 200cb98:	81 c7 e0 08 	ret                                            
 200cb9c:	81 e8 00 00 	restore                                        
                                                                      

0200eed4 <rtems_bdbuf_set_block_size>: rtems_status_code rtems_bdbuf_set_block_size (rtems_disk_device *dd, uint32_t block_size, bool sync) {
 200eed4:	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)                                                           
 200eed8:	80 a6 a0 00 	cmp  %i2, 0                                    
 200eedc:	02 80 00 04 	be  200eeec <rtems_bdbuf_set_block_size+0x18>  
 200eee0:	ba 10 00 18 	mov  %i0, %i5                                  
    rtems_bdbuf_syncdev (dd);                                         
 200eee4:	7f ff ff 79 	call  200ecc8 <rtems_bdbuf_syncdev>            
 200eee8:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  rtems_bdbuf_lock_cache ();                                          
 200eeec:	7f ff f6 eb 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200eef0:	b0 10 20 0a 	mov  0xa, %i0                                  
                                                                      
  if (block_size > 0)                                                 
 200eef4:	80 a6 60 00 	cmp  %i1, 0                                    
 200eef8:	02 80 00 30 	be  200efb8 <rtems_bdbuf_set_block_size+0xe4>  
 200eefc:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
rtems_bdbuf_bds_per_group (size_t size)                               
{                                                                     
  size_t bufs_per_size;                                               
  size_t bds_per_size;                                                
                                                                      
  if (size > bdbuf_config.buffer_max)                                 
 200ef00:	82 10 63 f8 	or  %g1, 0x3f8, %g1	! 201ebf8 <rtems_bdbuf_configuration>
 200ef04:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
 200ef08:	80 a6 40 02 	cmp  %i1, %g2                                  
 200ef0c:	18 80 00 2b 	bgu  200efb8 <rtems_bdbuf_set_block_size+0xe4> <== NEVER TAKEN
 200ef10:	01 00 00 00 	nop                                            
    return 0;                                                         
                                                                      
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;         
 200ef14:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
 200ef18:	40 00 36 1b 	call  201c784 <.udiv>                          
 200ef1c:	90 06 7f ff 	add  %i1, -1, %o0                              
                                                                      
  for (bds_per_size = 1;                                              
 200ef20:	92 10 20 01 	mov  1, %o1                                    
 200ef24:	90 02 20 01 	inc  %o0                                       
 200ef28:	80 a2 40 08 	cmp  %o1, %o0                                  
 200ef2c:	2a bf ff ff 	bcs,a   200ef28 <rtems_bdbuf_set_block_size+0x54>
 200ef30:	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;                
 200ef34:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200ef38:	d0 00 62 6c 	ld  [ %g1 + 0x26c ], %o0	! 202166c <bdbuf_cache+0x20>
 200ef3c:	40 00 36 12 	call  201c784 <.udiv>                          
 200ef40:	b0 10 20 0a 	mov  0xa, %i0                                  
                                                                      
  if (block_size > 0)                                                 
  {                                                                   
    size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);    
                                                                      
    if (bds_per_group != 0)                                           
 200ef44:	80 a2 20 00 	cmp  %o0, 0                                    
 200ef48:	02 80 00 1c 	be  200efb8 <rtems_bdbuf_set_block_size+0xe4>  <== NEVER TAKEN
 200ef4c:	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;
 200ef50:	f0 07 60 20 	ld  [ %i5 + 0x20 ], %i0                        
 200ef54:	90 10 00 19 	mov  %i1, %o0                                  
 200ef58:	40 00 36 0b 	call  201c784 <.udiv>                          
 200ef5c:	92 10 00 18 	mov  %i0, %o1                                  
  {                                                                   
    size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);    
                                                                      
    if (bds_per_group != 0)                                           
    {                                                                 
      int block_to_media_block_shift = 0;                             
 200ef60:	b8 10 20 00 	clr  %i4                                       
      uint32_t media_blocks_per_block = block_size / dd->media_block_size;
 200ef64:	b6 10 00 08 	mov  %o0, %i3                                  
 200ef68:	84 10 20 01 	mov  1, %g2                                    
      uint32_t one = 1;                                               
                                                                      
      while ((one << block_to_media_block_shift) < media_blocks_per_block)
 200ef6c:	83 28 80 1c 	sll  %g2, %i4, %g1                             
 200ef70:	80 a0 40 1b 	cmp  %g1, %i3                                  
 200ef74:	2a bf ff fe 	bcs,a   200ef6c <rtems_bdbuf_set_block_size+0x98>
 200ef78:	b8 07 20 01 	inc  %i4                                       
      {                                                               
        ++block_to_media_block_shift;                                 
      }                                                               
                                                                      
      if ((dd->media_block_size << block_to_media_block_shift) != block_size)
 200ef7c:	b1 2e 00 1c 	sll  %i0, %i4, %i0                             
 200ef80:	80 a6 00 19 	cmp  %i0, %i1                                  
 200ef84:	32 80 00 02 	bne,a   200ef8c <rtems_bdbuf_set_block_size+0xb8><== NEVER TAKEN
 200ef88:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
        block_to_media_block_shift = -1;                              
                                                                      
      dd->block_size = block_size;                                    
      dd->block_count = dd->size / media_blocks_per_block;            
 200ef8c:	d0 07 60 1c 	ld  [ %i5 + 0x1c ], %o0                        
 200ef90:	92 10 00 1b 	mov  %i3, %o1                                  
 200ef94:	40 00 35 fc 	call  201c784 <.udiv>                          
 200ef98:	f2 27 60 24 	st  %i1, [ %i5 + 0x24 ]                        
rtems_status_code                                                     
rtems_bdbuf_set_block_size (rtems_disk_device *dd,                    
                            uint32_t           block_size,            
                            bool               sync)                  
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
 200ef9c:	b0 10 20 00 	clr  %i0                                       
                                                                      
      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;            
 200efa0:	d0 27 60 28 	st  %o0, [ %i5 + 0x28 ]                        
      dd->media_blocks_per_block = media_blocks_per_block;            
 200efa4:	f6 27 60 2c 	st  %i3, [ %i5 + 0x2c ]                        
      dd->block_to_media_block_shift = block_to_media_block_shift;    
 200efa8:	f8 27 60 30 	st  %i4, [ %i5 + 0x30 ]                        
      dd->bds_per_group = bds_per_group;                              
 200efac:	f4 27 60 34 	st  %i2, [ %i5 + 0x34 ]                        
                                                                      
      rtems_bdbuf_purge_dev (dd);                                     
 200efb0:	7f ff ff 5d 	call  200ed24 <rtems_bdbuf_purge_dev>          
 200efb4:	90 10 00 1d 	mov  %i5, %o0                                  
  else                                                                
  {                                                                   
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200efb8:	7f ff f6 cd 	call  200caec <rtems_bdbuf_unlock_cache>       
 200efbc:	01 00 00 00 	nop                                            
                                                                      
  return sc;                                                          
}                                                                     
 200efc0:	81 c7 e0 08 	ret                                            
 200efc4:	81 e8 00 00 	restore                                        
                                                                      

0200d87c <rtems_bdbuf_swapout_modified_processing>: rtems_chain_control* chain, rtems_chain_control* transfer, bool sync_active, bool update_timers, uint32_t timer_delta) {
 200d87c:	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;                    
 200d880:	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 );                            
 200d884:	b2 06 60 04 	add  %i1, 4, %i1                               
  if (!rtems_chain_is_empty (chain))                                  
 200d888:	80 a0 40 19 	cmp  %g1, %i1                                  
 200d88c:	02 80 00 4e 	be  200d9c4 <rtems_bdbuf_swapout_modified_processing+0x148>
 200d890:	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))                
 200d894:	02 80 00 05 	be  200d8a8 <rtems_bdbuf_swapout_modified_processing+0x2c>
 200d898:	84 10 20 00 	clr  %g2                                       
 200d89c:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 200d8a0:	80 a0 00 02 	cmp  %g0, %g2                                  
 200d8a4:	84 60 3f ff 	subx  %g0, -1, %g2                             
}                                                                     
                                                                      
static bool                                                           
rtems_bdbuf_has_buffer_waiters (void)                                 
{                                                                     
  return bdbuf_cache.buffer_waiters.count;                            
 200d8a8:	07 00 80 85 	sethi  %hi(0x2021400), %g3                     
 200d8ac:	de 00 e2 c0 	ld  [ %g3 + 0x2c0 ], %o7	! 20216c0 <bdbuf_cache+0x74>
       * 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))            
 200d8b0:	9a 08 a0 ff 	and  %g2, 0xff, %o5                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200d8b4:	98 10 20 09 	mov  9, %o4                                    
       * 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))            
 200d8b8:	80 a3 60 00 	cmp  %o5, 0                                    
 200d8bc:	32 80 00 0d 	bne,a   200d8f0 <rtems_bdbuf_swapout_modified_processing+0x74>
 200d8c0:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
 200d8c4:	80 a6 e0 00 	cmp  %i3, 0                                    
 200d8c8:	02 80 00 07 	be  200d8e4 <rtems_bdbuf_swapout_modified_processing+0x68>
 200d8cc:	80 a3 e0 00 	cmp  %o7, 0                                    
 200d8d0:	c6 06 00 00 	ld  [ %i0 ], %g3                               
 200d8d4:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
 200d8d8:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200d8dc:	02 80 00 04 	be  200d8ec <rtems_bdbuf_swapout_modified_processing+0x70>
 200d8e0:	80 a3 e0 00 	cmp  %o7, 0                                    
          || rtems_bdbuf_has_buffer_waiters ())                       
 200d8e4:	22 80 00 04 	be,a   200d8f4 <rtems_bdbuf_swapout_modified_processing+0x78>
 200d8e8:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
        bd->hold_timer = 0;                                           
 200d8ec:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
                                                                      
      if (bd->hold_timer)                                             
 200d8f0:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
 200d8f4:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d8f8:	22 80 00 10 	be,a   200d938 <rtems_bdbuf_swapout_modified_processing+0xbc>
 200d8fc:	c4 06 00 00 	ld  [ %i0 ], %g2                               
      {                                                               
        if (update_timers)                                            
 200d900:	80 a7 20 00 	cmp  %i4, 0                                    
 200d904:	22 80 00 08 	be,a   200d924 <rtems_bdbuf_swapout_modified_processing+0xa8>
 200d908:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
        {                                                             
          if (bd->hold_timer > timer_delta)                           
 200d90c:	80 a0 80 1d 	cmp  %g2, %i5                                  
 200d910:	28 80 00 04 	bleu,a   200d920 <rtems_bdbuf_swapout_modified_processing+0xa4>
 200d914:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
            bd->hold_timer -= timer_delta;                            
 200d918:	84 20 80 1d 	sub  %g2, %i5, %g2                             
 200d91c:	c4 20 60 2c 	st  %g2, [ %g1 + 0x2c ]                        
          else                                                        
            bd->hold_timer = 0;                                       
        }                                                             
                                                                      
        if (bd->hold_timer)                                           
 200d920:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
 200d924:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d928:	22 80 00 04 	be,a   200d938 <rtems_bdbuf_swapout_modified_processing+0xbc>
 200d92c:	c4 06 00 00 	ld  [ %i0 ], %g2                               
        {                                                             
          node = node->next;                                          
          continue;                                                   
 200d930:	10 80 00 22 	b  200d9b8 <rtems_bdbuf_swapout_modified_processing+0x13c>
 200d934:	c2 00 40 00 	ld  [ %g1 ], %g1                               
      /*                                                              
       * 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)                               
 200d938:	80 a0 a0 00 	cmp  %g2, 0                                    
 200d93c:	32 80 00 05 	bne,a   200d950 <rtems_bdbuf_swapout_modified_processing+0xd4>
 200d940:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
        *dd_ptr = bd->dd;                                             
 200d944:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
 200d948:	c4 26 00 00 	st  %g2, [ %i0 ]                               
                                                                      
      if (bd->dd == *dd_ptr)                                          
 200d94c:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
 200d950:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 200d954:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200d958:	12 80 00 17 	bne  200d9b4 <rtems_bdbuf_swapout_modified_processing+0x138><== NEVER TAKEN
 200d95c:	c6 00 40 00 	ld  [ %g1 ], %g3                               
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 200d960:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200d964:	d8 20 60 20 	st  %o4, [ %g1 + 0x20 ]                        
  next->previous = previous;                                          
 200d968:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
 200d96c:	c6 20 80 00 	st  %g3, [ %g2 ]                               
                                                                      
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);       
                                                                      
        rtems_chain_extract_unprotected (node);                       
                                                                      
        tnode = tnode->previous;                                      
 200d970:	10 80 00 0c 	b  200d9a0 <rtems_bdbuf_swapout_modified_processing+0x124>
 200d974:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
                                                                      
        while (node && !rtems_chain_is_head (transfer, tnode))        
        {                                                             
          rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;      
                                                                      
          if (bd->block > tbd->block)                                 
 200d978:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
 200d97c:	80 a2 c0 04 	cmp  %o3, %g4                                  
 200d980:	28 80 00 08 	bleu,a   200d9a0 <rtems_bdbuf_swapout_modified_processing+0x124>
 200d984:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
 200d988:	c8 00 80 00 	ld  [ %g2 ], %g4                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
 200d98c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
 200d990:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  the_node->next        = before_node;                                
 200d994:	c8 20 40 00 	st  %g4, [ %g1 ]                               
  before_node->previous = the_node;                                   
 200d998:	10 80 00 07 	b  200d9b4 <rtems_bdbuf_swapout_modified_processing+0x138>
 200d99c:	c2 21 20 04 	st  %g1, [ %g4 + 4 ]                           
                                                                      
        rtems_chain_extract_unprotected (node);                       
                                                                      
        tnode = tnode->previous;                                      
                                                                      
        while (node && !rtems_chain_is_head (transfer, tnode))        
 200d9a0:	80 a0 80 1a 	cmp  %g2, %i2                                  
 200d9a4:	32 bf ff f5 	bne,a   200d978 <rtems_bdbuf_swapout_modified_processing+0xfc>
 200d9a8:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
 200d9ac:	10 80 00 08 	b  200d9cc <rtems_bdbuf_swapout_modified_processing+0x150>
 200d9b0:	c4 06 80 00 	ld  [ %i2 ], %g2                               
                                                                      
        node = next_node;                                             
      }                                                               
      else                                                            
      {                                                               
        node = node->next;                                            
 200d9b4:	82 10 00 03 	mov  %g3, %g1                                  
    if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))                
      sync_all = true;                                                
    else                                                              
      sync_all = false;                                               
                                                                      
    while (!rtems_chain_is_tail (chain, node))                        
 200d9b8:	80 a0 40 19 	cmp  %g1, %i1                                  
 200d9bc:	12 bf ff c0 	bne  200d8bc <rtems_bdbuf_swapout_modified_processing+0x40>
 200d9c0:	80 a3 60 00 	cmp  %o5, 0                                    
 200d9c4:	81 c7 e0 08 	ret                                            
 200d9c8:	81 e8 00 00 	restore                                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
 200d9cc:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
 200d9d0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  the_node->next        = before_node;                                
 200d9d4:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  before_node->previous = the_node;                                   
 200d9d8:	10 bf ff f7 	b  200d9b4 <rtems_bdbuf_swapout_modified_processing+0x138>
 200d9dc:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
                                                                      

0200dd08 <rtems_bdbuf_swapout_task>: * not this. * @return rtems_task Not used. */ static rtems_task rtems_bdbuf_swapout_task (rtems_task_argument arg) {
 200dd08:	9d e3 bf 80 	save  %sp, -128, %sp                           
  rtems_bdbuf_swapout_transfer transfer;                              
  uint32_t                     period_in_ticks;                       
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;
 200dd0c:	33 00 80 7a 	sethi  %hi(0x201e800), %i1                     
 200dd10:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 201ebf8 <rtems_bdbuf_configuration>
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
 200dd14:	7f ff fb de 	call  200cc8c <rtems_bdbuf_swapout_writereq_alloc>
 200dd18:	f6 06 60 0c 	ld  [ %i1 + 0xc ], %i3                         
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200dd1c:	82 07 bf ec 	add  %fp, -20, %g1                             
 200dd20:	c2 27 bf e8 	st  %g1, [ %fp + -24 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
 200dd24:	82 07 bf e8 	add  %fp, -24, %g1                             
 200dd28:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
 200dd2c:	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 ();         
 200dd30:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
  transfer.syncing = false;                                           
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
 200dd34:	91 2e e0 07 	sll  %i3, 7, %o0                               
 200dd38:	90 22 00 01 	sub  %o0, %g1, %o0                             
 200dd3c:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
 200dd40:	d2 00 63 bc 	ld  [ %g1 + 0x3bc ], %o1	! 201ebbc <Configuration+0xc>
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
 200dd44:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  const uint32_t               period_in_msecs = bdbuf_config.swapout_period;
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
  rtems_chain_initialize_empty (&transfer.bds);                       
  transfer.dd = BDBUF_INVALID_DEV;                                    
 200dd48:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  transfer.syncing = false;                                           
 200dd4c:	c0 2f bf f8 	clrb  [ %fp + -8 ]                             
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
 200dd50:	90 02 00 1b 	add  %o0, %i3, %o0                             
 200dd54:	40 00 3a 8c 	call  201c784 <.udiv>                          
 200dd58:	91 2a 20 03 	sll  %o0, 3, %o0                               
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 200dd5c:	35 00 80 85 	sethi  %hi(0x2021400), %i2                     
 200dd60:	a0 10 00 08 	mov  %o0, %l0                                  
rtems_bdbuf_swapout_workers_open (void)                               
{                                                                     
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
 200dd64:	7f ff fb 4d 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200dd68:	b4 16 a2 4c 	or  %i2, 0x24c, %i2                            
    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),
 200dd6c:	27 10 91 1b 	sethi  %hi(0x42446c00), %l3                    
 200dd70:	29 00 80 38 	sethi  %hi(0x200e000), %l4                     
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
 200dd74:	b8 10 20 00 	clr  %i4                                       
 200dd78:	f0 06 60 14 	ld  [ %i1 + 0x14 ], %i0                        
                                                                      
  the_node->next = tail;                                              
 200dd7c:	a2 06 a0 0c 	add  %i2, 0xc, %l1                             
    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;                                           
 200dd80:	a4 10 20 01 	mov  1, %l2                                    
    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),
 200dd84:	a6 14 e3 00 	or  %l3, 0x300, %l3                            
 200dd88:	10 80 00 23 	b  200de14 <rtems_bdbuf_swapout_task+0x10c>    
 200dd8c:	a8 15 20 2c 	or  %l4, 0x2c, %l4                             
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
  {                                                                   
    rtems_bdbuf_swapout_worker* worker;                               
                                                                      
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
 200dd90:	7f ff db e4 	call  2004d20 <malloc>                         <== NOT EXECUTED
 200dd94:	90 10 20 28 	mov  0x28, %o0                                 <== NOT EXECUTED
    if (!worker)                                                      
 200dd98:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
 200dd9c:	32 80 00 04 	bne,a   200ddac <rtems_bdbuf_swapout_task+0xa4><== NOT EXECUTED
 200dda0:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        <== NOT EXECUTED
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_NOMEM);              
 200dda4:	10 80 00 1a 	b  200de0c <rtems_bdbuf_swapout_task+0x104>    <== NOT EXECUTED
 200dda8:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
 200ddac:	e2 27 40 00 	st  %l1, [ %i5 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 200ddb0:	fa 20 40 00 	st  %i5, [ %g1 ]                               <== NOT EXECUTED
  the_node->previous = old_last;                                      
 200ddb4:	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;                                          
 200ddb8:	fa 26 a0 10 	st  %i5, [ %i2 + 0x10 ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
    worker->enabled = true;                                           
    worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
 200ddbc:	7f ff fb b4 	call  200cc8c <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
 200ddc0:	e4 2f 60 0c 	stb  %l2, [ %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),
 200ddc4:	d2 06 60 18 	ld  [ %i1 + 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 );                        
 200ddc8:	82 07 60 10 	add  %i5, 0x10, %g1                            <== NOT EXECUTED
 200ddcc:	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 ();
 200ddd0:	d0 27 60 24 	st  %o0, [ %i5 + 0x24 ]                        <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
 200ddd4:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        <== NOT EXECUTED
  head->previous = NULL;                                              
 200ddd8:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            <== NOT EXECUTED
  tail->previous = head;                                              
 200dddc:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
 200dde0:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            <== NOT EXECUTED
 * @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)                    
 200dde4:	90 07 20 61 	add  %i4, 0x61, %o0                            <== 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),
 200dde8:	94 10 00 14 	mov  %l4, %o2                                  <== NOT EXECUTED
 200ddec:	90 12 00 13 	or  %o0, %l3, %o0                              <== NOT EXECUTED
 200ddf0:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
 200ddf4:	7f ff fb e0 	call  200cd74 <rtems_bdbuf_create_task.constprop.10><== NOT EXECUTED
 200ddf8:	98 07 60 08 	add  %i5, 8, %o4                               <== 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)                                       
 200ddfc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 200de00:	22 80 00 05 	be,a   200de14 <rtems_bdbuf_swapout_task+0x10c><== NOT EXECUTED
 200de04:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);             
 200de08:	90 10 20 0d 	mov  0xd, %o0                                  <== NOT EXECUTED
 200de0c:	7f ff fb 12 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200de10:	01 00 00 00 	nop                                            <== NOT EXECUTED
  rtems_status_code sc;                                               
  size_t            w;                                                
                                                                      
  rtems_bdbuf_lock_cache ();                                          
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
 200de14:	80 a7 00 18 	cmp  %i4, %i0                                  
 200de18:	0a bf ff de 	bcs  200dd90 <rtems_bdbuf_swapout_task+0x88>   <== NEVER TAKEN
 200de1c:	01 00 00 00 	nop                                            
                                  &worker->id);                       
    if (sc != RTEMS_SUCCESSFUL)                                       
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WK_CREATE);             
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200de20:	7f ff fb 33 	call  200caec <rtems_bdbuf_unlock_cache>       
 200de24:	39 00 80 85 	sethi  %hi(0x2021400), %i4                     
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
 200de28:	b8 17 22 4c 	or  %i4, 0x24c, %i4	! 202164c <bdbuf_cache>    
 200de2c:	a2 07 20 08 	add  %i4, 8, %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,             
 200de30:	a4 07 20 58 	add  %i4, 0x58, %l2                            
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
 200de34:	10 80 00 5a 	b  200df9c <rtems_bdbuf_swapout_task+0x294>    
 200de38:	a6 07 20 4c 	add  %i4, 0x4c, %l3                            
                                rtems_bdbuf_swapout_transfer* transfer)
{                                                                     
  rtems_bdbuf_swapout_worker* worker;                                 
  bool                        transfered_buffers = false;             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
 200de3c:	7f ff fb 17 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200de40:	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)                                        
 200de44:	c2 0f 20 30 	ldub  [ %i4 + 0x30 ], %g1                      
 200de48:	80 a0 60 00 	cmp  %g1, 0                                    
 200de4c:	02 80 00 04 	be  200de5c <rtems_bdbuf_swapout_task+0x154>   
 200de50:	b4 10 20 00 	clr  %i2                                       
      /*                                                              
       * 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,                
 200de54:	10 80 00 08 	b  200de74 <rtems_bdbuf_swapout_task+0x16c>    
 200de58:	ba 07 bf e8 	add  %fp, -24, %i5                             
 200de5c:	7f ff fa ea 	call  200ca04 <_Chain_Get_unprotected>         
 200de60:	90 10 00 11 	mov  %l1, %o0                                  
    worker = NULL;                                                    
  else                                                                
  {                                                                   
    worker = (rtems_bdbuf_swapout_worker*)                            
      rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);     
    if (worker)                                                       
 200de64:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 200de68:	22 bf ff fb 	be,a   200de54 <rtems_bdbuf_swapout_task+0x14c><== ALWAYS TAKEN
 200de6c:	b4 10 20 00 	clr  %i2                                       
      transfer = &worker->transfer;                                   
 200de70:	ba 06 a0 10 	add  %i2, 0x10, %i5                            <== 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 );                        
 200de74:	82 07 60 04 	add  %i5, 4, %g1                               
                                                                      
  head->next = tail;                                                  
 200de78:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dd = BDBUF_INVALID_DEV;                                   
  transfer->syncing = bdbuf_cache.sync_active;                        
 200de7c:	c2 0f 20 30 	ldub  [ %i4 + 0x30 ], %g1                      
  head->previous = NULL;                                              
 200de80:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
  tail->previous = head;                                              
 200de84:	fa 27 60 08 	st  %i5, [ %i5 + 8 ]                           
    if (worker)                                                       
      transfer = &worker->transfer;                                   
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dd = BDBUF_INVALID_DEV;                                   
 200de88:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
  /*                                                                  
   * 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)                                        
 200de8c:	80 88 60 ff 	btst  0xff, %g1                                
 200de90:	02 80 00 04 	be  200dea0 <rtems_bdbuf_swapout_task+0x198>   
 200de94:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    transfer->dd = bdbuf_cache.sync_device;                           
 200de98:	c2 07 20 38 	ld  [ %i4 + 0x38 ], %g1                        
 200de9c:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
                                                                      
  /*                                                                  
   * 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,             
 200dea0:	b0 07 60 0c 	add  %i5, 0xc, %i0                             
 200dea4:	92 10 00 12 	mov  %l2, %o1                                  
 200dea8:	90 10 00 18 	mov  %i0, %o0                                  
 200deac:	94 10 00 1d 	mov  %i5, %o2                                  
 200deb0:	96 10 20 01 	mov  1, %o3                                    
 200deb4:	98 10 20 00 	clr  %o4                                       
 200deb8:	7f ff fe 71 	call  200d87c <rtems_bdbuf_swapout_modified_processing>
 200debc:	9a 10 00 1b 	mov  %i3, %o5                                  
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
 200dec0:	d6 0f 20 30 	ldub  [ %i4 + 0x30 ], %o3                      
 200dec4:	90 10 00 18 	mov  %i0, %o0                                  
 200dec8:	92 10 00 13 	mov  %l3, %o1                                  
 200decc:	94 10 00 1d 	mov  %i5, %o2                                  
 200ded0:	98 0e 60 01 	and  %i1, 1, %o4                               
 200ded4:	7f ff fe 6a 	call  200d87c <rtems_bdbuf_swapout_modified_processing>
 200ded8:	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 ();                                        
 200dedc:	7f ff fb 04 	call  200caec <rtems_bdbuf_unlock_cache>       
 200dee0:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
 200dee4:	c4 07 40 00 	ld  [ %i5 ], %g2                               
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(                            
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_first( the_chain )                          
    == _Chain_Immutable_tail( the_chain );                            
 200dee8:	82 07 60 04 	add  %i5, 4, %g1                               
 200deec:	80 a0 80 01 	cmp  %g2, %g1                                  
 200def0:	02 80 00 10 	be  200df30 <rtems_bdbuf_swapout_task+0x228>   
 200def4:	80 a6 a0 00 	cmp  %i2, 0                                    
  {                                                                   
    if (worker)                                                       
 200def8:	02 80 00 0a 	be  200df20 <rtems_bdbuf_swapout_task+0x218>   <== ALWAYS TAKEN
 200defc:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_status_code sc = rtems_event_send (worker->id,            
 200df00:	d0 06 a0 08 	ld  [ %i2 + 8 ], %o0                           <== NOT EXECUTED
 200df04:	7f ff e9 d0 	call  2008644 <rtems_event_send>               <== NOT EXECUTED
 200df08:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
                                               RTEMS_BDBUF_SWAPOUT_SYNC);
      if (sc != RTEMS_SUCCESSFUL)                                     
 200df0c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 200df10:	02 80 00 09 	be  200df34 <rtems_bdbuf_swapout_task+0x22c>   <== NOT EXECUTED
 200df14:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_2);              
 200df18:	10 bf ff bd 	b  200de0c <rtems_bdbuf_swapout_task+0x104>    <== NOT EXECUTED
 200df1c:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
    }                                                                 
    else                                                              
    {                                                                 
      rtems_bdbuf_swapout_write (transfer);                           
 200df20:	7f ff ff 22 	call  200dba8 <rtems_bdbuf_swapout_write>      
 200df24:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
                                                                      
    transfered_buffers = true;                                        
 200df28:	10 80 00 03 	b  200df34 <rtems_bdbuf_swapout_task+0x22c>    
 200df2c:	82 10 20 01 	mov  1, %g1                                    
 200df30:	82 10 20 00 	clr  %g1                                       
  }                                                                   
                                                                      
  if (bdbuf_cache.sync_active && !transfered_buffers)                 
 200df34:	c4 0f 20 30 	ldub  [ %i4 + 0x30 ], %g2                      
 200df38:	b2 10 20 00 	clr  %i1                                       
 200df3c:	80 a0 a0 00 	cmp  %g2, 0                                    
 200df40:	02 80 00 13 	be  200df8c <rtems_bdbuf_swapout_task+0x284>   
 200df44:	82 08 60 ff 	and  %g1, 0xff, %g1                            
 200df48:	80 a0 60 00 	cmp  %g1, 0                                    
 200df4c:	12 bf ff bc 	bne  200de3c <rtems_bdbuf_swapout_task+0x134>  
 200df50:	01 00 00 00 	nop                                            
  {                                                                   
    rtems_id sync_requester;                                          
    rtems_bdbuf_lock_cache ();                                        
 200df54:	7f ff fa d1 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200df58:	01 00 00 00 	nop                                            
    sync_requester = bdbuf_cache.sync_requester;                      
 200df5c:	fa 07 20 34 	ld  [ %i4 + 0x34 ], %i5                        
    bdbuf_cache.sync_active = false;                                  
 200df60:	c0 2f 20 30 	clrb  [ %i4 + 0x30 ]                           
    bdbuf_cache.sync_requester = 0;                                   
    rtems_bdbuf_unlock_cache ();                                      
 200df64:	7f ff fa e2 	call  200caec <rtems_bdbuf_unlock_cache>       
 200df68:	c0 27 20 34 	clr  [ %i4 + 0x34 ]                            
    if (sync_requester)                                               
 200df6c:	80 a7 60 00 	cmp  %i5, 0                                    
 200df70:	22 80 00 23 	be,a   200dffc <rtems_bdbuf_swapout_task+0x2f4><== NEVER TAKEN
 200df74:	90 10 20 04 	mov  4, %o0                                    <== NOT EXECUTED
 200df78:	90 10 00 1d 	mov  %i5, %o0                                  
 200df7c:	7f ff eb 55 	call  2008cd0 <rtems_event_system_send>        
 200df80:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
       */                                                             
      update_timers = false;                                          
    }                                                                 
    while (transfered_buffers);                                       
                                                                      
    sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,               
 200df84:	10 80 00 1e 	b  200dffc <rtems_bdbuf_swapout_task+0x2f4>    
 200df88:	90 10 20 04 	mov  4, %o0                                    
      /*                                                              
       * 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,                
 200df8c:	80 a0 60 00 	cmp  %g1, 0                                    
 200df90:	02 80 00 1b 	be  200dffc <rtems_bdbuf_swapout_task+0x2f4>   
 200df94:	90 10 20 04 	mov  4, %o0                                    
 200df98:	30 bf ff a9 	b,a   200de3c <rtems_bdbuf_swapout_task+0x134> 
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
 200df9c:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
 200dfa0:	80 a0 60 00 	cmp  %g1, 0                                    
 200dfa4:	12 bf ff a6 	bne  200de3c <rtems_bdbuf_swapout_task+0x134>  <== ALWAYS TAKEN
 200dfa8:	b2 10 20 01 	mov  1, %i1                                    
static void                                                           
rtems_bdbuf_swapout_workers_close (void)                              
{                                                                     
  rtems_chain_node* node;                                             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
 200dfac:	7f ff fa bb 	call  200ca98 <rtems_bdbuf_lock_cache>         <== NOT EXECUTED
 200dfb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 200dfb4:	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))   
 200dfb8:	10 80 00 06 	b  200dfd0 <rtems_bdbuf_swapout_task+0x2c8>    <== NOT EXECUTED
 200dfbc:	b8 07 20 0c 	add  %i4, 0xc, %i4                             <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
    worker->enabled = false;                                          
 200dfc0:	c0 2f 60 0c 	clrb  [ %i5 + 0xc ]                            <== NOT EXECUTED
    rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);          
 200dfc4:	7f ff e9 a0 	call  2008644 <rtems_event_send>               <== NOT EXECUTED
 200dfc8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
 200dfcc:	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))   
 200dfd0:	80 a7 40 1c 	cmp  %i5, %i4                                  <== NOT EXECUTED
 200dfd4:	32 bf ff fb 	bne,a   200dfc0 <rtems_bdbuf_swapout_task+0x2b8><== NOT EXECUTED
 200dfd8:	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 ();                                        
 200dfdc:	7f ff fa c4 	call  200caec <rtems_bdbuf_unlock_cache>       <== NOT EXECUTED
 200dfe0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);               
  }                                                                   
                                                                      
  rtems_bdbuf_swapout_workers_close ();                               
                                                                      
  free (transfer.write_req);                                          
 200dfe4:	7f ff da 0e 	call  200481c <free>                           <== NOT EXECUTED
 200dfe8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
 200dfec:	7f ff eb 98 	call  2008e4c <rtems_task_delete>              <== NOT EXECUTED
 200dff0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 200dff4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200dff8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
       */                                                             
      update_timers = false;                                          
    }                                                                 
    while (transfered_buffers);                                       
                                                                      
    sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,               
 200dffc:	92 10 20 00 	clr  %o1                                       
 200e000:	94 10 00 10 	mov  %l0, %o2                                  
 200e004:	7f ff e9 2e 	call  20084bc <rtems_event_receive>            
 200e008:	96 07 bf e4 	add  %fp, -28, %o3                             
                              RTEMS_EVENT_ALL | RTEMS_WAIT,           
                              period_in_ticks,                        
                              &out);                                  
                                                                      
    if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))            
 200e00c:	80 a2 20 06 	cmp  %o0, 6                                    
 200e010:	22 bf ff e4 	be,a   200dfa0 <rtems_bdbuf_swapout_task+0x298>
 200e014:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
 200e018:	80 a2 20 00 	cmp  %o0, 0                                    
 200e01c:	22 bf ff e1 	be,a   200dfa0 <rtems_bdbuf_swapout_task+0x298><== ALWAYS TAKEN
 200e020:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
 200e024:	10 bf ff 7a 	b  200de0c <rtems_bdbuf_swapout_task+0x104>    <== NOT EXECUTED
 200e028:	90 10 20 18 	mov  0x18, %o0                                 <== NOT EXECUTED
                                                                      

0200e02c <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) {
 200e02c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 200e030:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     <== NOT EXECUTED
                                                                      
  while (worker->enabled)                                             
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
                                                                      
    rtems_bdbuf_swapout_write (&worker->transfer);                    
 200e034:	b8 06 20 10 	add  %i0, 0x10, %i4                            <== NOT EXECUTED
 200e038:	ba 17 62 4c 	or  %i5, 0x24c, %i5                            <== 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 );                        
 200e03c:	b6 06 20 14 	add  %i0, 0x14, %i3                            <== 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)                                             
 200e040:	10 80 00 12 	b  200e088 <rtems_bdbuf_swapout_worker_task+0x5c><== NOT EXECUTED
 200e044:	b4 07 60 0c 	add  %i5, 0xc, %i2                             <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
 200e048:	7f ff fb 00 	call  200cc48 <rtems_bdbuf_wait_for_event>     <== NOT EXECUTED
 200e04c:	90 10 20 04 	mov  4, %o0                                    <== NOT EXECUTED
                                                                      
    rtems_bdbuf_swapout_write (&worker->transfer);                    
 200e050:	7f ff fe d6 	call  200dba8 <rtems_bdbuf_swapout_write>      <== NOT EXECUTED
 200e054:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
    rtems_bdbuf_lock_cache ();                                        
 200e058:	7f ff fa 90 	call  200ca98 <rtems_bdbuf_lock_cache>         <== NOT EXECUTED
 200e05c:	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;                              
 200e060:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 200e064:	f6 26 20 10 	st  %i3, [ %i0 + 0x10 ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
 200e068:	c0 26 20 1c 	clr  [ %i0 + 0x1c ]                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200e06c:	f4 26 00 00 	st  %i2, [ %i0 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
 200e070:	f0 27 60 10 	st  %i0, [ %i5 + 0x10 ]                        <== NOT EXECUTED
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
 200e074:	c0 26 20 14 	clr  [ %i0 + 0x14 ]                            <== NOT EXECUTED
  tail->previous = head;                                              
 200e078:	f8 26 20 18 	st  %i4, [ %i0 + 0x18 ]                        <== NOT EXECUTED
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 200e07c:	f0 20 40 00 	st  %i0, [ %g1 ]                               <== NOT EXECUTED
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
 200e080:	7f ff fa 9b 	call  200caec <rtems_bdbuf_unlock_cache>       <== NOT EXECUTED
 200e084:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           <== NOT EXECUTED
static rtems_task                                                     
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)             
{                                                                     
  rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
                                                                      
  while (worker->enabled)                                             
 200e088:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
 200e08c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 200e090:	12 bf ff ee 	bne  200e048 <rtems_bdbuf_swapout_worker_task+0x1c><== NOT EXECUTED
 200e094:	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);                                  
 200e098:	7f ff d9 e1 	call  200481c <free>                           <== NOT EXECUTED
 200e09c:	d0 06 20 24 	ld  [ %i0 + 0x24 ], %o0                        <== NOT EXECUTED
  free (worker);                                                      
 200e0a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200e0a4:	7f ff d9 de 	call  200481c <free>                           <== NOT EXECUTED
 200e0a8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
 200e0ac:	7f ff eb 68 	call  2008e4c <rtems_task_delete>              <== NOT EXECUTED
 200e0b0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200dba8 <rtems_bdbuf_swapout_write>: * * @param transfer The transfer transaction. */ static void rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer) {
 200dba8:	9d e3 bf a0 	save  %sp, -96, %sp                            
    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))                         
 200dbac:	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 );                            
 200dbb0:	b6 06 20 04 	add  %i0, 4, %i3                               
 200dbb4:	80 a0 40 1b 	cmp  %g1, %i3                                  
 200dbb8:	02 80 00 52 	be  200dd00 <rtems_bdbuf_swapout_write+0x158>  <== NEVER TAKEN
 200dbbc:	84 10 20 0c 	mov  0xc, %g2                                  
     * 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;                             
 200dbc0:	fa 06 20 0c 	ld  [ %i0 + 0xc ], %i5                         
    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;
 200dbc4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
     * 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;     
 200dbc8:	f4 07 60 2c 	ld  [ %i5 + 0x2c ], %i2                        
    bool need_continuous_blocks =                                     
      (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
 200dbcc:	f2 00 60 0c 	ld  [ %g1 + 0xc ], %i1                         
     * 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;              
 200dbd0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    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;
 200dbd4:	b2 0e 60 01 	and  %i1, 1, %i1                               
     * 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;              
 200dbd8:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
    transfer->write_req->bufnum = 0;                                  
 200dbdc:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
  {                                                                   
    /*                                                                
     * The last block number used when the driver only supports       
     * continuous blocks in a single request.                         
     */                                                               
    uint32_t last_block = 0;                                          
 200dbe0:	b8 10 20 00 	clr  %i4                                       
                                                                      
      if (write)                                                      
      {                                                               
        rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
 200dbe4:	a0 10 20 0c 	mov  0xc, %l0                                  
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    transfer->write_req->bufnum = 0;                                  
                                                                      
    while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
 200dbe8:	10 80 00 35 	b  200dcbc <rtems_bdbuf_swapout_write+0x114>   
 200dbec:	23 00 80 7a 	sethi  %hi(0x201e800), %l1                     
      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 &&    
 200dbf0:	02 80 00 12 	be  200dc38 <rtems_bdbuf_swapout_write+0x90>   
 200dbf4:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 200dbf8:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 200dbfc:	80 a0 a0 00 	cmp  %g2, 0                                    
 200dc00:	22 80 00 0f 	be,a   200dc3c <rtems_bdbuf_swapout_write+0x94>
 200dc04:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
 200dc08:	c6 02 20 18 	ld  [ %o0 + 0x18 ], %g3                        
          bd->block != last_block + media_blocks_per_block)           
 200dc0c:	84 07 00 1a 	add  %i4, %i2, %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 &&    
 200dc10:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200dc14:	22 80 00 0a 	be,a   200dc3c <rtems_bdbuf_swapout_write+0x94>
 200dc18:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
 200dc1c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
 200dc20:	f0 22 20 04 	st  %i0, [ %o0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
 200dc24:	d0 26 00 00 	st  %o0, [ %i0 ]                               
  the_node->next        = before_node;                                
 200dc28:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  before_node->previous = the_node;                                   
 200dc2c:	d0 20 60 04 	st  %o0, [ %g1 + 4 ]                           
          bd->block != last_block + media_blocks_per_block)           
      {                                                               
        rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);  
        write = true;                                                 
 200dc30:	10 80 00 10 	b  200dc70 <rtems_bdbuf_swapout_write+0xc8>    
 200dc34:	82 10 20 01 	mov  1, %g1                                    
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
 200dc38:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
 200dc3c:	f8 02 20 18 	ld  [ %o0 + 0x18 ], %i4                        
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
 200dc40:	87 29 20 04 	sll  %g4, 4, %g3                               
        transfer->write_req->bufnum++;                                
 200dc44:	88 01 20 01 	inc  %g4                                       
 200dc48:	c8 20 60 10 	st  %g4, [ %g1 + 0x10 ]                        
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
 200dc4c:	86 00 e0 18 	add  %g3, 0x18, %g3                            
 200dc50:	84 00 40 03 	add  %g1, %g3, %g2                             
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
 200dc54:	f8 20 40 03 	st  %i4, [ %g1 + %g3 ]                         
        buf->length = dd->block_size;                                 
 200dc58:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
 200dc5c:	d0 20 a0 0c 	st  %o0, [ %g2 + 0xc ]                         
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
 200dc60:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
        buf->buffer = bd->buffer;                                     
 200dc64:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
 200dc68:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
    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;                              
 200dc6c:	82 10 20 00 	clr  %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) ||                    
 200dc70:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 200dc74:	80 a0 80 1b 	cmp  %g2, %i3                                  
 200dc78:	02 80 00 0b 	be  200dca4 <rtems_bdbuf_swapout_write+0xfc>   
 200dc7c:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
 200dc80:	84 14 63 f8 	or  %l1, 0x3f8, %g2                            
      /*                                                              
       * 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) ||                    
 200dc84:	c6 02 60 10 	ld  [ %o1 + 0x10 ], %g3                        
 200dc88:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
 200dc8c:	80 a0 c0 02 	cmp  %g3, %g2                                  
 200dc90:	1a 80 00 06 	bcc  200dca8 <rtems_bdbuf_swapout_write+0x100> 
 200dc94:	90 10 00 1d 	mov  %i5, %o0                                  
          (transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
        write = true;                                                 
                                                                      
      if (write)                                                      
 200dc98:	80 88 60 ff 	btst  0xff, %g1                                
 200dc9c:	02 80 00 08 	be  200dcbc <rtems_bdbuf_swapout_write+0x114>  
 200dca0:	01 00 00 00 	nop                                            
      {                                                               
        rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
 200dca4:	90 10 00 1d 	mov  %i5, %o0                                  
 200dca8:	7f ff ff 54 	call  200d9f8 <rtems_bdbuf_execute_transfer_request>
 200dcac:	94 10 20 00 	clr  %o2                                       
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
 200dcb0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 200dcb4:	e0 20 60 0c 	st  %l0, [ %g1 + 0xc ]                         
        transfer->write_req->bufnum = 0;                              
 200dcb8:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get_unprotected(   
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get_unprotected( the_chain );                         
 200dcbc:	7f ff fb 52 	call  200ca04 <_Chain_Get_unprotected>         
 200dcc0:	90 10 00 18 	mov  %i0, %o0                                  
     * trouble waiting to happen.                                     
     */                                                               
    transfer->write_req->status = RTEMS_RESOURCE_IN_USE;              
    transfer->write_req->bufnum = 0;                                  
                                                                      
    while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
 200dcc4:	80 a2 20 00 	cmp  %o0, 0                                    
 200dcc8:	12 bf ff ca 	bne  200dbf0 <rtems_bdbuf_swapout_write+0x48>  
 200dccc:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
    /*                                                                
     * If sync'ing and the deivce is capability of handling a sync IO control
     * call perform the call.                                         
     */                                                               
    if (transfer->syncing &&                                          
 200dcd0:	c2 0e 20 10 	ldub  [ %i0 + 0x10 ], %g1                      
 200dcd4:	80 a0 60 00 	cmp  %g1, 0                                    
 200dcd8:	02 80 00 0a 	be  200dd00 <rtems_bdbuf_swapout_write+0x158>  
 200dcdc:	01 00 00 00 	nop                                            
        (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))         
 200dce0:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
 200dce4:	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 &&                                          
 200dce8:	80 88 60 02 	btst  2, %g1                                   
 200dcec:	02 80 00 05 	be  200dd00 <rtems_bdbuf_swapout_write+0x158>  <== ALWAYS TAKEN
 200dcf0:	92 10 20 02 	mov  2, %o1                                    
        (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))         
    {                                                                 
      /* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
 200dcf4:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        <== NOT EXECUTED
 200dcf8:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 200dcfc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 200dd00:	81 c7 e0 08 	ret                                            
 200dd04:	81 e8 00 00 	restore                                        
                                                                      

0200cc8c <rtems_bdbuf_swapout_writereq_alloc>: * * @return rtems_blkdev_request* The write reference memory. */ static rtems_blkdev_request* rtems_bdbuf_swapout_writereq_alloc (void) {
 200cc8c:	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)));
 200cc90:	03 00 80 7a 	sethi  %hi(0x201e800), %g1                     
 200cc94:	d0 00 63 fc 	ld  [ %g1 + 0x3fc ], %o0	! 201ebfc <rtems_bdbuf_configuration+0x4>
 200cc98:	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 =                                   
 200cc9c:	7f ff e0 21 	call  2004d20 <malloc>                         
 200cca0:	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)                                                     
 200cca4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200cca8:	12 80 00 04 	bne  200ccb8 <rtems_bdbuf_swapout_writereq_alloc+0x2c><== ALWAYS TAKEN
 200ccac:	82 10 20 01 	mov  1, %g1                                    
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);               
 200ccb0:	7f ff ff 69 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200ccb4:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
                                                                      
  write_req->req = RTEMS_BLKDEV_REQ_WRITE;                            
 200ccb8:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  write_req->done = rtems_bdbuf_transfer_done;                        
 200ccbc:	03 00 80 36 	sethi  %hi(0x200d800), %g1                     
 200ccc0:	82 10 61 e0 	or  %g1, 0x1e0, %g1	! 200d9e0 <rtems_bdbuf_transfer_done>
  write_req->io_task = rtems_task_self ();                            
 200ccc4:	40 00 11 6c 	call  2011274 <rtems_task_self>                
 200ccc8:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
 200cccc:	d0 26 20 14 	st  %o0, [ %i0 + 0x14 ]                        
                                                                      
  return write_req;                                                   
}                                                                     
 200ccd0:	81 c7 e0 08 	ret                                            
 200ccd4:	81 e8 00 00 	restore                                        
                                                                      

0200eb94 <rtems_bdbuf_sync>: rtems_status_code rtems_bdbuf_sync (rtems_bdbuf_buffer *bd) {
 200eb94:	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)                                                     
 200eb98:	80 a6 20 00 	cmp  %i0, 0                                    
 200eb9c:	02 80 00 49 	be  200ecc0 <rtems_bdbuf_sync+0x12c>           <== NEVER TAKEN
 200eba0:	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();                                           
 200eba4:	7f ff f7 bd 	call  200ca98 <rtems_bdbuf_lock_cache>         
 200eba8:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");              
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
 200ebac:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
 200ebb0:	80 a2 20 03 	cmp  %o0, 3                                    
 200ebb4:	0a 80 00 3d 	bcs  200eca8 <rtems_bdbuf_sync+0x114>          <== NEVER TAKEN
 200ebb8:	92 10 20 11 	mov  0x11, %o1                                 
 200ebbc:	80 a2 20 05 	cmp  %o0, 5                                    
 200ebc0:	08 80 00 06 	bleu  200ebd8 <rtems_bdbuf_sync+0x44>          
 200ebc4:	82 10 20 08 	mov  8, %g1                                    
 200ebc8:	80 a2 20 06 	cmp  %o0, 6                                    
 200ebcc:	12 80 00 37 	bne  200eca8 <rtems_bdbuf_sync+0x114>          <== NEVER TAKEN
 200ebd0:	01 00 00 00 	nop                                            
 200ebd4:	30 80 00 32 	b,a   200ec9c <rtems_bdbuf_sync+0x108>         
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
 200ebd8:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
 200ebdc:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
 200ebe0:	90 12 22 4c 	or  %o0, 0x24c, %o0                            
 200ebe4:	c2 02 20 60 	ld  [ %o0 + 0x60 ], %g1                        
                                                                      
  the_node->next = tail;                                              
 200ebe8:	84 02 20 5c 	add  %o0, 0x5c, %g2                            
  tail->previous = the_node;                                          
 200ebec:	f0 22 20 60 	st  %i0, [ %o0 + 0x60 ]                        
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
 200ebf0:	c4 26 00 00 	st  %g2, [ %i0 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
 200ebf4:	f0 20 40 00 	st  %i0, [ %g1 ]                               
  the_node->previous = old_last;                                      
 200ebf8:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
{                                                                     
  rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);                 
                                                                      
  rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);      
                                                                      
  if (bd->waiters)                                                    
 200ebfc:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 200ec00:	80 a0 60 00 	cmp  %g1, 0                                    
 200ec04:	02 80 00 04 	be  200ec14 <rtems_bdbuf_sync+0x80>            
 200ec08:	01 00 00 00 	nop                                            
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
 200ec0c:	7f ff f8 4c 	call  200cd3c <rtems_bdbuf_wake>               
 200ec10:	90 02 20 64 	add  %o0, 0x64, %o0                            
                                                                      
  rtems_bdbuf_wake_swapper ();                                        
 200ec14:	7f ff f7 bc 	call  200cb04 <rtems_bdbuf_wake_swapper>       
 200ec18:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     
      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);         
 200ec1c:	ba 17 62 b8 	or  %i5, 0x2b8, %i5	! 20216b8 <bdbuf_cache+0x6c>
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200ec20:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
 200ec24:	80 a2 20 01 	cmp  %o0, 1                                    
 200ec28:	0a 80 00 20 	bcs  200eca8 <rtems_bdbuf_sync+0x114>          <== NEVER TAKEN
 200ec2c:	92 10 20 15 	mov  0x15, %o1                                 
 200ec30:	80 a2 20 07 	cmp  %o0, 7                                    
 200ec34:	28 80 00 0a 	bleu,a   200ec5c <rtems_bdbuf_sync+0xc8>       
 200ec38:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 200ec3c:	80 a2 20 0a 	cmp  %o0, 0xa                                  
 200ec40:	18 80 00 1a 	bgu  200eca8 <rtems_bdbuf_sync+0x114>          <== NEVER TAKEN
 200ec44:	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);         
 200ec48:	90 10 00 18 	mov  %i0, %o0                                  
 200ec4c:	7f ff f7 f2 	call  200cc14 <rtems_bdbuf_wait>               
 200ec50:	92 10 00 1d 	mov  %i5, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
 200ec54:	10 bf ff f4 	b  200ec24 <rtems_bdbuf_sync+0x90>             
 200ec58:	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                                                
 200ec5c:	80 a0 60 00 	cmp  %g1, 0                                    
 200ec60:	12 80 00 14 	bne  200ecb0 <rtems_bdbuf_sync+0x11c>          
 200ec64:	82 02 3f ff 	add  %o0, -1, %g1                              
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
 200ec68:	80 a0 60 01 	cmp  %g1, 1                                    
 200ec6c:	18 80 00 11 	bgu  200ecb0 <rtems_bdbuf_sync+0x11c>          <== NEVER TAKEN
 200ec70:	80 a2 20 01 	cmp  %o0, 1                                    
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
  {                                                                   
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                         
 200ec74:	32 80 00 07 	bne,a   200ec90 <rtems_bdbuf_sync+0xfc>        
 200ec78:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
    {                                                                 
      rtems_bdbuf_remove_from_tree (bd);                              
 200ec7c:	7f ff f8 55 	call  200cdd0 <rtems_bdbuf_remove_from_tree>   
 200ec80:	90 10 00 18 	mov  %i0, %o0                                  
      rtems_bdbuf_make_free_and_add_to_lru_list (bd);                 
 200ec84:	7f ff f9 39 	call  200d168 <rtems_bdbuf_make_free_and_add_to_lru_list>
 200ec88:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
 200ec8c:	11 00 80 85 	sethi  %hi(0x2021400), %o0                     
 200ec90:	7f ff f8 2b 	call  200cd3c <rtems_bdbuf_wake>               
 200ec94:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 20216c0 <bdbuf_cache+0x74>
 200ec98:	30 80 00 06 	b,a   200ecb0 <rtems_bdbuf_sync+0x11c>         
    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);                   
 200ec9c:	7f ff fd 96 	call  200e2f4 <rtems_bdbuf_discard_buffer_after_access>
 200eca0:	90 10 00 18 	mov  %i0, %o0                                  
      break;                                                          
 200eca4:	30 80 00 03 	b,a   200ecb0 <rtems_bdbuf_sync+0x11c>         
    default:                                                          
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);
 200eca8:	7f ff f7 82 	call  200cab0 <rtems_bdbuf_fatal_with_state>   <== NOT EXECUTED
 200ecac:	01 00 00 00 	nop                                            <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
 200ecb0:	7f ff f7 8f 	call  200caec <rtems_bdbuf_unlock_cache>       
 200ecb4:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200ecb8:	81 c7 e0 08 	ret                                            
 200ecbc:	81 e8 00 00 	restore                                        
}                                                                     
 200ecc0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200ecc4:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      

0200cac4 <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) {
 200cac4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_semaphore_release (lock);              
 200cac8:	7f ff f0 55 	call  2008c1c <rtems_semaphore_release>        
 200cacc:	90 10 00 18 	mov  %i0, %o0                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
 200cad0:	80 a2 20 00 	cmp  %o0, 0                                    
 200cad4:	02 80 00 04 	be  200cae4 <rtems_bdbuf_unlock+0x20>          <== ALWAYS TAKEN
 200cad8:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (fatal_error_code);                             
 200cadc:	7f ff ff de 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cae0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 200cae4:	81 c7 e0 08 	ret                                            
 200cae8:	81 e8 00 00 	restore                                        
                                                                      

0200cc48 <rtems_bdbuf_wait_for_event>: return RTEMS_UNSATISFIED; } static void rtems_bdbuf_wait_for_event (rtems_event_set event) {
 200cc48:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_event_set   out = 0;                                          
                                                                      
  sc = rtems_event_receive (event,                                    
 200cc4c:	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;                                          
 200cc50:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  sc = rtems_event_receive (event,                                    
 200cc54:	90 10 00 18 	mov  %i0, %o0                                  
 200cc58:	94 10 20 00 	clr  %o2                                       
 200cc5c:	7f ff ee 18 	call  20084bc <rtems_event_receive>            
 200cc60:	96 07 bf fc 	add  %fp, -4, %o3                              
                            RTEMS_EVENT_ALL | RTEMS_WAIT,             
                            RTEMS_NO_TIMEOUT,                         
                            &out);                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL || out != event)                         
 200cc64:	80 a2 20 00 	cmp  %o0, 0                                    
 200cc68:	12 80 00 05 	bne  200cc7c <rtems_bdbuf_wait_for_event+0x34> <== NEVER TAKEN
 200cc6c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200cc70:	80 a0 40 18 	cmp  %g1, %i0                                  
 200cc74:	02 80 00 04 	be  200cc84 <rtems_bdbuf_wait_for_event+0x3c>  <== ALWAYS TAKEN
 200cc78:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);                  
 200cc7c:	7f ff ff 76 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cc80:	90 10 20 1c 	mov  0x1c, %o0	! 1c <PROM_START+0x1c>          <== NOT EXECUTED
 200cc84:	81 c7 e0 08 	ret                                            
 200cc88:	81 e8 00 00 	restore                                        
                                                                      

0200d134 <rtems_bdbuf_wait_for_transient_event>: rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT); } static void rtems_bdbuf_wait_for_transient_event (void) {
 200d134:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_interval ticks                                                
)                                                                     
{                                                                     
  rtems_event_set event_out;                                          
                                                                      
  return rtems_event_system_receive(                                  
 200d138:	11 20 00 00 	sethi  %hi(0x80000000), %o0                    
 200d13c:	92 10 20 00 	clr  %o1                                       
 200d140:	94 10 20 00 	clr  %o2                                       
 200d144:	40 00 0f cc 	call  2011074 <rtems_event_system_receive>     
 200d148:	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)                                         
 200d14c:	80 a2 20 00 	cmp  %o0, 0                                    
 200d150:	02 80 00 04 	be  200d160 <rtems_bdbuf_wait_for_transient_event+0x2c><== ALWAYS TAKEN
 200d154:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);            
 200d158:	7f ff fe 3f 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200d15c:	90 10 20 1d 	mov  0x1d, %o0	! 1d <PROM_START+0x1d>          <== NOT EXECUTED
 200d160:	81 c7 e0 08 	ret                                            
 200d164:	81 e8 00 00 	restore                                        
                                                                      

0200cd3c <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) {
 200cd3c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (waiters->count > 0)                                             
 200cd40:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 200cd44:	80 a0 60 00 	cmp  %g1, 0                                    
 200cd48:	02 80 00 09 	be  200cd6c <rtems_bdbuf_wake+0x30>            
 200cd4c:	01 00 00 00 	nop                                            
  {                                                                   
    sc = rtems_semaphore_flush (waiters->sema);                       
 200cd50:	40 00 10 9f 	call  2010fcc <rtems_semaphore_flush>          
 200cd54:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
    if (sc != RTEMS_SUCCESSFUL)                                       
 200cd58:	80 a2 20 00 	cmp  %o0, 0                                    
 200cd5c:	02 80 00 04 	be  200cd6c <rtems_bdbuf_wake+0x30>            <== ALWAYS TAKEN
 200cd60:	01 00 00 00 	nop                                            
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);               
 200cd64:	7f ff ff 3c 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cd68:	90 10 20 04 	mov  4, %o0	! 4 <PROM_START+0x4>               <== NOT EXECUTED
 200cd6c:	81 c7 e0 08 	ret                                            
 200cd70:	81 e8 00 00 	restore                                        
                                                                      

0200cb04 <rtems_bdbuf_wake_swapper>: } } static void rtems_bdbuf_wake_swapper (void) {
 200cb04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,       
 200cb08:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200cb0c:	d0 00 62 4c 	ld  [ %g1 + 0x24c ], %o0	! 202164c <bdbuf_cache>
 200cb10:	7f ff ee cd 	call  2008644 <rtems_event_send>               
 200cb14:	92 10 20 04 	mov  4, %o1                                    
                                           RTEMS_BDBUF_SWAPOUT_SYNC); 
  if (sc != RTEMS_SUCCESSFUL)                                         
 200cb18:	80 a2 20 00 	cmp  %o0, 0                                    
 200cb1c:	02 80 00 04 	be  200cb2c <rtems_bdbuf_wake_swapper+0x28>    <== ALWAYS TAKEN
 200cb20:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);                  
 200cb24:	7f ff ff cc 	call  200ca54 <rtems_bdbuf_fatal>              <== NOT EXECUTED
 200cb28:	90 10 20 0b 	mov  0xb, %o0	! b <PROM_START+0xb>             <== NOT EXECUTED
 200cb2c:	81 c7 e0 08 	ret                                            
 200cb30:	81 e8 00 00 	restore                                        
                                                                      

02002e04 <rtems_bdpart_create>: const rtems_bdpart_format *format, rtems_bdpart_partition *pt, const unsigned *dist, size_t count ) {
 2002e04:	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;                                 
 2002e08:	80 a6 60 00 	cmp  %i1, 0                                    
 2002e0c:	02 80 00 08 	be  2002e2c <rtems_bdpart_create+0x28>         <== NEVER TAKEN
 2002e10:	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                        
 2002e14:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2002e18:	80 a0 60 00 	cmp  %g1, 0                                    
 2002e1c:	12 80 00 05 	bne  2002e30 <rtems_bdpart_create+0x2c>        <== NEVER TAKEN
 2002e20:	a0 10 20 00 	clr  %l0                                       
    && format->mbr.dos_compatibility;                                 
 2002e24:	10 80 00 03 	b  2002e30 <rtems_bdpart_create+0x2c>          
 2002e28:	e0 0e 60 08 	ldub  [ %i1 + 8 ], %l0                         
 2002e2c:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
  const unsigned *dist,                                               
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
 2002e30:	a0 0c 20 01 	and  %l0, 1, %l0                               
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
  rtems_blkdev_bnum disk_end = 0;                                     
 2002e34:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  rtems_blkdev_bnum pos = 0;                                          
  rtems_blkdev_bnum dist_sum = 0;                                     
  rtems_blkdev_bnum record_space =                                    
 2002e38:	82 0c 20 ff 	and  %l0, 0xff, %g1                            
 2002e3c:	80 a0 00 01 	cmp  %g0, %g1                                  
  size_t i = 0;                                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
 2002e40:	b0 10 20 00 	clr  %i0                                       
    && 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 =                                    
 2002e44:	ba 40 3f ff 	addx  %g0, -1, %i5                             
  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) {                                                   
 2002e48:	80 a7 20 00 	cmp  %i4, 0                                    
    && 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 =                                    
 2002e4c:	ba 0f 7f c2 	and  %i5, -62, %i5                             
  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) {                                                   
 2002e50:	02 80 00 70 	be  2003010 <rtems_bdpart_create+0x20c>        <== NEVER TAKEN
 2002e54:	ba 07 60 3f 	add  %i5, 0x3f, %i5                            
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || dist == NULL) {                 
 2002e58:	80 a6 a0 00 	cmp  %i2, 0                                    
 2002e5c:	02 80 00 6d 	be  2003010 <rtems_bdpart_create+0x20c>        <== NEVER TAKEN
 2002e60:	b0 10 20 09 	mov  9, %i0                                    
 2002e64:	80 a6 60 00 	cmp  %i1, 0                                    
 2002e68:	02 80 00 6a 	be  2003010 <rtems_bdpart_create+0x20c>        <== NEVER TAKEN
 2002e6c:	80 a6 e0 00 	cmp  %i3, 0                                    
 2002e70:	02 80 00 68 	be  2003010 <rtems_bdpart_create+0x20c>        <== NEVER TAKEN
 2002e74:	92 10 20 00 	clr  %o1                                       
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end); 
 2002e78:	94 10 20 00 	clr  %o2                                       
 2002e7c:	40 00 01 2a 	call  2003324 <rtems_bdpart_get_disk_data>     
 2002e80:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2002e84:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2002e88:	12 80 00 62 	bne  2003010 <rtems_bdpart_create+0x20c>       <== NEVER TAKEN
 2002e8c:	82 10 20 00 	clr  %g1                                       
 2002e90:	84 10 20 00 	clr  %g2                                       
#endif                                                                
                                                                      
#include <rtems.h>                                                    
#include <rtems/bdpart.h>                                             
                                                                      
rtems_status_code rtems_bdpart_create(                                
 2002e94:	87 28 60 02 	sll  %g1, 2, %g3                               
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
    unsigned prev_sum = dist_sum;                                     
                                                                      
    dist_sum += dist [i];                                             
 2002e98:	c6 06 c0 03 	ld  [ %i3 + %g3 ], %g3                         
 2002e9c:	a8 00 c0 02 	add  %g3, %g2, %l4                             
                                                                      
    if (dist_sum < prev_sum) {                                        
 2002ea0:	80 a5 00 02 	cmp  %l4, %g2                                  
 2002ea4:	1a 80 00 04 	bcc  2002eb4 <rtems_bdpart_create+0xb0>        <== ALWAYS TAKEN
 2002ea8:	80 a0 e0 00 	cmp  %g3, 0                                    
      return RTEMS_INVALID_NUMBER;                                    
 2002eac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2002eb0:	91 e8 20 0a 	restore  %g0, 0xa, %o0                         <== NOT EXECUTED
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
 2002eb4:	02 bf ff fe 	be  2002eac <rtems_bdpart_create+0xa8>         <== NEVER TAKEN
 2002eb8:	82 00 60 01 	inc  %g1                                       
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* Get distribution sum and check for overflow */                   
  for (i = 0; i < count; ++i) {                                       
 2002ebc:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2002ec0:	12 bf ff f5 	bne  2002e94 <rtems_bdpart_create+0x90>        
 2002ec4:	84 10 00 14 	mov  %l4, %g2                                  
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
 2002ec8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2002ecc:	80 a0 60 00 	cmp  %g1, 0                                    
 2002ed0:	12 80 00 52 	bne  2003018 <rtems_bdpart_create+0x214>       <== NEVER TAKEN
 2002ed4:	80 8c 20 ff 	btst  0xff, %l0                                
    return RTEMS_NOT_IMPLEMENTED;                                     
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
 2002ed8:	02 80 00 09 	be  2002efc <rtems_bdpart_create+0xf8>         <== NEVER TAKEN
 2002edc:	80 a7 20 04 	cmp  %i4, 4                                    
    disk_end -= (disk_end % record_space);                            
 2002ee0:	f2 07 bf fc 	ld  [ %fp + -4 ], %i1                          
 2002ee4:	92 10 00 1d 	mov  %i5, %o1                                  
 2002ee8:	40 00 7b 46 	call  2021c00 <.urem>                          
 2002eec:	90 10 00 19 	mov  %i1, %o0                                  
 2002ef0:	90 26 40 08 	sub  %i1, %o0, %o0                             
 2002ef4:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
  /*                                                                  
   * In case we need an extended partition and logical partitions we have to
   * account for the space of each EBR.                               
   */                                                                 
  if (count > 4) {                                                    
 2002ef8:	80 a7 20 04 	cmp  %i4, 4                                    
 2002efc:	08 80 00 06 	bleu  2002f14 <rtems_bdpart_create+0x110>      <== NEVER TAKEN
 2002f00:	b2 10 00 1d 	mov  %i5, %i1                                  
    overhead += (count - 3) * record_space;                           
 2002f04:	90 10 00 1d 	mov  %i5, %o0                                  
 2002f08:	40 00 7a 58 	call  2021868 <.umul>                          
 2002f0c:	92 07 3f fd 	add  %i4, -3, %o1                              
 2002f10:	b2 02 00 1d 	add  %o0, %i5, %i1                             
                                                                      
  /*                                                                  
   * Account space to align every partition on cylinder boundaries if 
   * necessary.                                                       
   */                                                                 
  if (dos_compatibility) {                                            
 2002f14:	80 8c 20 ff 	btst  0xff, %l0                                
 2002f18:	02 80 00 07 	be  2002f34 <rtems_bdpart_create+0x130>        <== NEVER TAKEN
 2002f1c:	e6 07 bf fc 	ld  [ %fp + -4 ], %l3                          
    overhead += (count - 1) * record_space;                           
 2002f20:	90 10 00 1d 	mov  %i5, %o0                                  
 2002f24:	40 00 7a 51 	call  2021868 <.umul>                          
 2002f28:	92 07 3f ff 	add  %i4, -1, %o1                              
 2002f2c:	b2 06 40 08 	add  %i1, %o0, %i1                             
  }                                                                   
                                                                      
  /* Check disk space */                                              
  if ((overhead + count) > disk_end) {                                
 2002f30:	e6 07 bf fc 	ld  [ %fp + -4 ], %l3                          
 2002f34:	82 06 40 1c 	add  %i1, %i4, %g1                             
 2002f38:	80 a0 40 13 	cmp  %g1, %l3                                  
 2002f3c:	38 80 00 35 	bgu,a   2003010 <rtems_bdpart_create+0x20c>    <== NEVER TAKEN
 2002f40:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
                                                                      
  /* Begin of first primary partition */                              
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
 2002f44:	aa 24 c0 19 	sub  %l3, %i1, %l5                             
 2002f48:	a2 10 00 1a 	mov  %i2, %l1                                  
  if ((overhead + count) > disk_end) {                                
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  /* Begin of first primary partition */                              
  pos = record_space;                                                 
 2002f4c:	a0 10 00 1d 	mov  %i5, %l0                                  
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
 2002f50:	b2 10 20 00 	clr  %i1                                       
#endif                                                                
                                                                      
#include <rtems.h>                                                    
#include <rtems/bdpart.h>                                             
                                                                      
rtems_status_code rtems_bdpart_create(                                
 2002f54:	83 2e 60 02 	sll  %i1, 2, %g1                               
                                                                      
  for (i = 0; i < count; ++i) {                                       
    rtems_bdpart_partition *p = pt + i;                               
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
 2002f58:	e4 06 c0 01 	ld  [ %i3 + %g1 ], %l2                         
 2002f5c:	92 10 00 15 	mov  %l5, %o1                                  
 2002f60:	40 00 7a 42 	call  2021868 <.umul>                          
 2002f64:	90 10 00 12 	mov  %l2, %o0                                  
    if (s < free_space || s < dist [i]) {                             
 2002f68:	80 a2 00 15 	cmp  %o0, %l5                                  
 2002f6c:	0a bf ff d0 	bcs  2002eac <rtems_bdpart_create+0xa8>        <== NEVER TAKEN
 2002f70:	80 a2 00 12 	cmp  %o0, %l2                                  
 2002f74:	0a bf ff ce 	bcs  2002eac <rtems_bdpart_create+0xa8>        <== NEVER TAKEN
 2002f78:	01 00 00 00 	nop                                            
      /* TODO: Calculate without overflow */                          
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
 2002f7c:	40 00 7a 75 	call  2021950 <.udiv>                          
 2002f80:	92 10 00 14 	mov  %l4, %o1                                  
                                                                      
    /* Ensure that the partition is not empty */                      
    if (s == 0) {                                                     
 2002f84:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 2002f88:	22 80 00 02 	be,a   2002f90 <rtems_bdpart_create+0x18c>     <== NEVER TAKEN
 2002f8c:	a4 10 20 01 	mov  1, %l2                                    <== NOT EXECUTED
      s = 1;                                                          
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
 2002f90:	90 10 00 12 	mov  %l2, %o0                                  
 2002f94:	40 00 7b 1b 	call  2021c00 <.urem>                          
 2002f98:	92 10 00 1d 	mov  %i5, %o1                                  
 2002f9c:	a4 04 80 1d 	add  %l2, %i5, %l2                             
                                                                      
    /* Reserve space for the EBR if necessary */                      
    if (count > 4 && i > 2) {                                         
 2002fa0:	82 10 20 01 	mov  1, %g1                                    
 2002fa4:	80 a6 60 02 	cmp  %i1, 2                                    
 2002fa8:	18 80 00 03 	bgu  2002fb4 <rtems_bdpart_create+0x1b0>       
 2002fac:	90 24 80 08 	sub  %l2, %o0, %o0                             
 2002fb0:	82 10 20 00 	clr  %g1                                       
 2002fb4:	80 88 60 ff 	btst  0xff, %g1                                
 2002fb8:	22 80 00 0a 	be,a   2002fe0 <rtems_bdpart_create+0x1dc>     
 2002fbc:	e0 24 40 00 	st  %l0, [ %l1 ]                               
 2002fc0:	80 a7 20 04 	cmp  %i4, 4                                    
 2002fc4:	18 80 00 03 	bgu  2002fd0 <rtems_bdpart_create+0x1cc>       <== ALWAYS TAKEN
 2002fc8:	82 10 20 01 	mov  1, %g1                                    
 2002fcc:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
 2002fd0:	80 88 60 ff 	btst  0xff, %g1                                
 2002fd4:	32 80 00 02 	bne,a   2002fdc <rtems_bdpart_create+0x1d8>    <== ALWAYS TAKEN
 2002fd8:	a0 04 00 1d 	add  %l0, %i5, %l0                             
      pos += record_space;                                            
    }                                                                 
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
 2002fdc:	e0 24 40 00 	st  %l0, [ %l1 ]                               
    pos += s;                                                         
 2002fe0:	a0 04 00 08 	add  %l0, %o0, %l0                             
    p->end = pos;                                                     
 2002fe4:	e0 24 60 04 	st  %l0, [ %l1 + 4 ]                           
  pos = record_space;                                                 
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
 2002fe8:	b2 06 60 01 	inc  %i1                                       
 2002fec:	80 a6 40 1c 	cmp  %i1, %i4                                  
 2002ff0:	12 bf ff d9 	bne  2002f54 <rtems_bdpart_create+0x150>       
 2002ff4:	a2 04 60 30 	add  %l1, 0x30, %l1                            
    pos += s;                                                         
    p->end = pos;                                                     
  }                                                                   
                                                                      
  /* Expand the last partition to the disk end */                     
  pt [count - 1].end = disk_end;                                      
 2002ff8:	b2 06 7f ff 	add  %i1, -1, %i1                              
 2002ffc:	83 2e 60 04 	sll  %i1, 4, %g1                               
 2003000:	b3 2e 60 06 	sll  %i1, 6, %i1                               
 2003004:	b2 26 40 01 	sub  %i1, %g1, %i1                             
 2003008:	b4 06 80 19 	add  %i2, %i1, %i2                             
 200300c:	e6 26 a0 04 	st  %l3, [ %i2 + 4 ]                           
 2003010:	81 c7 e0 08 	ret                                            
 2003014:	81 e8 00 00 	restore                                        
 2003018:	b0 10 20 18 	mov  0x18, %i0                                 <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 200301c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003020:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003024 <rtems_bdpart_dump>: { uuid_unparse_lower( type, str); } void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count) {
 2003024:	9d e3 bf 60 	save  %sp, -160, %sp                           
  size_t i = 0;                                                       
                                                                      
  printf(                                                             
 2003028:	11 00 80 90 	sethi  %hi(0x2024000), %o0                     
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
 200302c:	35 00 80 90 	sethi  %hi(0x2024000), %i2                     
                                                                      
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  printf(                                                             
 2003030:	90 12 21 90 	or  %o0, 0x190, %o0                            
 2003034:	40 00 4a 55 	call  2015988 <puts>                           
 2003038:	27 00 80 90 	sethi  %hi(0x2024000), %l3                     
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
 200303c:	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";                                            
 2003040:	37 00 80 90 	sethi  %hi(0x2024000), %i3                     
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
 2003044:	b4 16 a2 d0 	or  %i2, 0x2d0, %i2                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
 2003048:	21 00 80 90 	sethi  %hi(0x2024000), %l0                     
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
 200304c:	23 00 80 90 	sethi  %hi(0x2024000), %l1                     
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
 2003050:	25 00 80 90 	sethi  %hi(0x2024000), %l2                     
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
 2003054:	10 80 00 39 	b  2003138 <rtems_bdpart_dump+0x114>           
 2003058:	a6 14 e2 d8 	or  %l3, 0x2d8, %l3                            
    const rtems_bdpart_partition *p = pt + i;                         
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
 200305c:	b8 06 20 08 	add  %i0, 8, %i4                               
 2003060:	92 07 bf c7 	add  %fp, -57, %o1                             
 2003064:	40 00 00 a4 	call  20032f4 <rtems_bdpart_to_mbr_partition_type>
 2003068:	90 10 00 1c 	mov  %i4, %o0                                  
 200306c:	80 8a 20 ff 	btst  0xff, %o0                                
 2003070:	22 80 00 27 	be,a   200310c <rtems_bdpart_dump+0xe8>        <== NEVER TAKEN
 2003074:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      switch (type_mbr) {                                             
 2003078:	d6 0f bf c7 	ldub  [ %fp + -57 ], %o3                       
 200307c:	82 0a e0 ff 	and  %o3, 0xff, %g1                            
 2003080:	80 a0 60 0b 	cmp  %g1, 0xb                                  
 2003084:	22 80 00 27 	be,a   2003120 <rtems_bdpart_dump+0xfc>        <== ALWAYS TAKEN
 2003088:	96 16 e1 78 	or  %i3, 0x178, %o3                            
 200308c:	18 80 00 09 	bgu  20030b0 <rtems_bdpart_dump+0x8c>          <== NOT EXECUTED
 2003090:	80 a0 60 0e 	cmp  %g1, 0xe                                  <== NOT EXECUTED
 2003094:	80 a0 60 01 	cmp  %g1, 1                                    <== NOT EXECUTED
 2003098:	02 80 00 0e 	be  20030d0 <rtems_bdpart_dump+0xac>           <== NOT EXECUTED
 200309c:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
 20030a0:	12 80 00 15 	bne  20030f4 <rtems_bdpart_dump+0xd0>          <== NOT EXECUTED
 20030a4:	90 07 bf c8 	add  %fp, -56, %o0                             <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_12:                                 
          type = "FAT 12";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
 20030a8:	10 80 00 1d 	b  200311c <rtems_bdpart_dump+0xf8>            <== NOT EXECUTED
 20030ac:	17 00 80 90 	sethi  %hi(0x2024000), %o3                     <== NOT EXECUTED
    const char *type = NULL;                                          
    char type_buffer [52];                                            
    uint8_t type_mbr = 0;                                             
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
      switch (type_mbr) {                                             
 20030b0:	02 80 00 0b 	be  20030dc <rtems_bdpart_dump+0xb8>           <== NOT EXECUTED
 20030b4:	80 a0 60 da 	cmp  %g1, 0xda                                 <== NOT EXECUTED
 20030b8:	02 80 00 0d 	be  20030ec <rtems_bdpart_dump+0xc8>           <== NOT EXECUTED
 20030bc:	80 a0 60 0c 	cmp  %g1, 0xc                                  <== NOT EXECUTED
 20030c0:	12 80 00 0d 	bne  20030f4 <rtems_bdpart_dump+0xd0>          <== NOT EXECUTED
 20030c4:	90 07 bf c8 	add  %fp, -56, %o0                             <== NOT EXECUTED
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
 20030c8:	10 80 00 07 	b  20030e4 <rtems_bdpart_dump+0xc0>            <== NOT EXECUTED
 20030cc:	96 14 a1 68 	or  %l2, 0x168, %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";                                            
 20030d0:	17 00 80 90 	sethi  %hi(0x2024000), %o3                     <== NOT EXECUTED
 20030d4:	10 80 00 13 	b  2003120 <rtems_bdpart_dump+0xfc>            <== NOT EXECUTED
 20030d8:	96 12 e1 58 	or  %o3, 0x158, %o3	! 2024158 <Configuration_Initial_Extensions+0x4d8><== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
          break;                                                      
 20030dc:	10 80 00 11 	b  2003120 <rtems_bdpart_dump+0xfc>            <== NOT EXECUTED
 20030e0:	96 14 21 80 	or  %l0, 0x180, %o3                            <== NOT EXECUTED
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
 20030e4:	10 80 00 10 	b  2003124 <rtems_bdpart_dump+0x100>           <== NOT EXECUTED
 20030e8:	d2 06 00 00 	ld  [ %i0 ], %o1                               <== NOT EXECUTED
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
 20030ec:	10 80 00 0d 	b  2003120 <rtems_bdpart_dump+0xfc>            <== NOT EXECUTED
 20030f0:	96 14 61 60 	or  %l1, 0x160, %o3                            <== NOT EXECUTED
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
 20030f4:	92 10 20 34 	mov  0x34, %o1                                 <== NOT EXECUTED
 20030f8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 20030fc:	40 00 4a dc 	call  2015c6c <snprintf>                       <== NOT EXECUTED
 2003100:	96 0a e0 ff 	and  %o3, 0xff, %o3                            <== NOT EXECUTED
          type = type_buffer;                                         
          break;                                                      
      }                                                               
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
 2003104:	10 80 00 07 	b  2003120 <rtems_bdpart_dump+0xfc>            <== NOT EXECUTED
 2003108:	96 07 bf c8 	add  %fp, -56, %o3                             <== NOT EXECUTED
static void rtems_bdpart_type_to_string(                              
  const uuid_t type,                                                  
  char str [37]                                                       
)                                                                     
{                                                                     
  uuid_unparse_lower( type, str);                                     
 200310c:	40 00 2b 47 	call  200de28 <uuid_unparse_lower>             <== NOT EXECUTED
 2003110:	92 07 bf c8 	add  %fp, -56, %o1                             <== NOT EXECUTED
          type = type_buffer;                                         
          break;                                                      
      }                                                               
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
 2003114:	10 80 00 03 	b  2003120 <rtems_bdpart_dump+0xfc>            <== NOT EXECUTED
 2003118:	96 07 bf c8 	add  %fp, -56, %o3                             <== NOT EXECUTED
      switch (type_mbr) {                                             
        case RTEMS_BDPART_MBR_FAT_12:                                 
          type = "FAT 12";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
 200311c:	96 12 e1 50 	or  %o3, 0x150, %o3                            <== NOT EXECUTED
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
 2003120:	d2 06 00 00 	ld  [ %i0 ], %o1                               
 2003124:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
 2003128:	90 10 00 13 	mov  %l3, %o0                                  
 200312c:	40 00 49 e1 	call  20158b0 <printf>                         
 2003130:	ba 07 60 01 	inc  %i5                                       
 2003134:	b0 06 20 30 	add  %i0, 0x30, %i0                            
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
 2003138:	80 a7 40 19 	cmp  %i5, %i1                                  
 200313c:	32 bf ff c8 	bne,a   200305c <rtems_bdpart_dump+0x38>       
 2003140:	c0 2f bf c7 	clrb  [ %fp + -57 ]                            
      p->end,                                                         
      type                                                            
    );                                                                
  }                                                                   
                                                                      
  puts( "------------+------------+-----------------------------------------------------");
 2003144:	11 00 80 90 	sethi  %hi(0x2024000), %o0                     
 2003148:	40 00 4a 10 	call  2015988 <puts>                           
 200314c:	90 12 22 80 	or  %o0, 0x280, %o0	! 2024280 <Configuration_Initial_Extensions+0x600>
 2003150:	81 c7 e0 08 	ret                                            
 2003154:	81 e8 00 00 	restore                                        
                                                                      

02003324 <rtems_bdpart_get_disk_data>: const char *disk_name, int *fd_ptr, rtems_disk_device **dd_ptr, rtems_blkdev_bnum *disk_end ) {
 2003324:	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);                                      
 2003328:	92 10 20 02 	mov  2, %o1                                    
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int rv = 0;                                                         
  int fd = -1;                                                        
  rtems_disk_device *dd = NULL;                                       
 200332c:	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);                                      
 2003330:	40 00 0d 12 	call  2006778 <open>                           
 2003334:	90 10 00 18 	mov  %i0, %o0                                  
  if (fd < 0) {                                                       
 2003338:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200333c:	36 80 00 04 	bge,a   200334c <rtems_bdpart_get_disk_data+0x28><== ALWAYS TAKEN
 2003340:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
    sc = RTEMS_INVALID_NAME;                                          
 2003344:	10 80 00 12 	b  200338c <rtems_bdpart_get_disk_data+0x68>   <== NOT EXECUTED
 2003348:	b0 10 20 03 	mov  3, %i0                                    <== 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);                   
 200334c:	94 07 bf fc 	add  %fp, -4, %o2                              
 2003350:	40 00 09 cb 	call  2005a7c <ioctl>                          
 2003354:	92 12 62 09 	or  %o1, 0x209, %o1                            
    goto error;                                                       
  }                                                                   
                                                                      
  /* Get disk handle */                                               
  rv = rtems_disk_fd_get_disk_device( fd, &dd);                       
  if (rv != 0) {                                                      
 2003358:	80 a2 20 00 	cmp  %o0, 0                                    
 200335c:	32 80 00 0c 	bne,a   200338c <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
 2003360:	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;                                             
 2003364:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  *disk_end = dd->size;                                               
 2003368:	c4 18 60 18 	ldd  [ %g1 + 0x18 ], %g2                       
 200336c:	c6 26 c0 00 	st  %g3, [ %i3 ]                               
  block_size = dd->block_size;                                        
                                                                      
  /* Check block size */                                              
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {                         
 2003370:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
 2003374:	80 a0 61 ff 	cmp  %g1, 0x1ff                                
 2003378:	08 80 00 05 	bleu  200338c <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
 200337c:	b0 10 20 1b 	mov  0x1b, %i0                                 
  int *fd_ptr,                                                        
  rtems_disk_device **dd_ptr,                                         
  rtems_blkdev_bnum *disk_end                                         
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
 2003380:	80 a0 00 02 	cmp  %g0, %g2                                  
 2003384:	b0 60 20 00 	subx  %g0, 0, %i0                              
 2003388:	b0 0e 20 1b 	and  %i0, 0x1b, %i0                            
    goto error;                                                       
  }                                                                   
                                                                      
error:                                                                
                                                                      
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {   
 200338c:	80 a6 20 00 	cmp  %i0, 0                                    
 2003390:	12 80 00 0a 	bne  20033b8 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
 2003394:	80 a6 60 00 	cmp  %i1, 0                                    
 2003398:	02 80 00 08 	be  20033b8 <rtems_bdpart_get_disk_data+0x94>  
 200339c:	80 a6 a0 00 	cmp  %i2, 0                                    
 20033a0:	02 80 00 06 	be  20033b8 <rtems_bdpart_get_disk_data+0x94>  <== NEVER TAKEN
 20033a4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    *fd_ptr = fd;                                                     
 20033a8:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    *dd_ptr = dd;                                                     
 20033ac:	c2 26 80 00 	st  %g1, [ %i2 ]                               
 20033b0:	81 c7 e0 08 	ret                                            
 20033b4:	81 e8 00 00 	restore                                        
  } else {                                                            
    close( fd);                                                       
 20033b8:	40 00 08 77 	call  2005594 <close>                          
 20033bc:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 20033c0:	81 c7 e0 08 	ret                                            
 20033c4:	81 e8 00 00 	restore                                        
                                                                      

0202152c <rtems_bdpart_mount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
 202152c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
 2021530:	92 10 20 2f 	mov  0x2f, %o1                                 <== NOT EXECUTED
 2021534:	40 00 75 5f 	call  203eab0 <strrchr>                        <== NOT EXECUTED
 2021538:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 202153c:	ba 10 00 08 	mov  %o0, %i5                                  <== 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);                         
 2021540:	40 00 71 39 	call  203da24 <strlen>                         <== NOT EXECUTED
 2021544:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2021548:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
 202154c:	40 00 71 36 	call  203da24 <strlen>                         <== NOT EXECUTED
 2021550:	90 10 00 1b 	mov  %i3, %o0                                  <== 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;                                           
 2021554:	b8 10 20 1a 	mov  0x1a, %i4                                 <== 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);                       
 2021558:	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);
 202155c:	7f ff 88 4c 	call  200368c <malloc>                         <== NOT EXECUTED
 2021560:	90 04 20 04 	add  %l0, 4, %o0                               <== NOT EXECUTED
  if (logical_disk_name == NULL) {                                    
 2021564:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2021568:	02 80 00 4d 	be  202169c <rtems_bdpart_mount+0x170>         <== NOT EXECUTED
 202156c:	b2 10 00 08 	mov  %o0, %i1                                  <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
 2021570:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 2021574:	40 00 71 e8 	call  203dd14 <strncpy>                        <== NOT EXECUTED
 2021578:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
 202157c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
 2021580:	22 80 00 06 	be,a   2021598 <rtems_bdpart_mount+0x6c>       <== NOT EXECUTED
 2021584:	a4 10 00 10 	mov  %l0, %l2                                  <== NOT EXECUTED
    disk_file_name += 1;                                              
 2021588:	b0 07 60 01 	add  %i5, 1, %i0                               <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
 202158c:	40 00 71 26 	call  203da24 <strlen>                         <== NOT EXECUTED
 2021590:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2021594:	a4 10 00 08 	mov  %o0, %l2                                  <== 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);
 2021598:	a6 04 80 11 	add  %l2, %l1, %l3                             <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
 202159c:	b8 10 20 1a 	mov  0x1a, %i4                                 <== 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);
 20215a0:	7f ff 88 3b 	call  200368c <malloc>                         <== NOT EXECUTED
 20215a4:	90 04 e0 05 	add  %l3, 5, %o0                               <== NOT EXECUTED
  if (mount_point == NULL) {                                          
 20215a8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 20215ac:	02 80 00 38 	be  202168c <rtems_bdpart_mount+0x160>         <== NOT EXECUTED
 20215b0:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
 20215b4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 20215b8:	40 00 71 d7 	call  203dd14 <strncpy>                        <== NOT EXECUTED
 20215bc:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
 20215c0:	82 10 20 2f 	mov  0x2f, %g1                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
 20215c4:	92 10 00 18 	mov  %i0, %o1                                  <== 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] = '/';                                
 20215c8:	c2 2f 40 11 	stb  %g1, [ %i5 + %l1 ]                        <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
 20215cc:	90 04 60 01 	add  %l1, 1, %o0                               <== NOT EXECUTED
 20215d0:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
 20215d4:	90 07 40 08 	add  %i5, %o0, %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;
 20215d8:	a6 04 e0 01 	inc  %l3                                       <== 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);
 20215dc:	37 00 81 68 	sethi  %hi(0x205a000), %i3                     <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
  mount_point [mount_base_size] = '/';                                
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
 20215e0:	40 00 71 cd 	call  203dd14 <strncpy>                        <== NOT EXECUTED
 20215e4:	31 00 81 61 	sethi  %hi(0x2058400), %i0                     <== NOT EXECUTED
                                                                      
  /* Markers */                                                       
  logical_disk_marker = logical_disk_name + disk_name_size;           
 20215e8:	a0 06 40 10 	add  %i1, %l0, %l0                             <== NOT EXECUTED
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
 20215ec:	a6 07 40 13 	add  %i5, %l3, %l3                             <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
 20215f0:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
 20215f4:	b6 16 e0 c0 	or  %i3, 0xc0, %i3                             <== 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) {                                       
 20215f8:	10 80 00 1d 	b  202166c <rtems_bdpart_mount+0x140>          <== NOT EXECUTED
 20215fc:	b0 16 21 28 	or  %i0, 0x128, %i0                            <== NOT EXECUTED
    /* Create logical disk name */                                    
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
 2021600:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 2021604:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 2021608:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
 202160c:	40 00 6d 68 	call  203cbac <snprintf>                       <== NOT EXECUTED
 2021610:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
 2021614:	80 a2 20 03 	cmp  %o0, 3                                    <== NOT EXECUTED
 2021618:	14 80 00 1a 	bg  2021680 <rtems_bdpart_mount+0x154>         <== NOT EXECUTED
 202161c:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create mount point */                                          
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
 2021620:	94 10 20 04 	mov  4, %o2                                    <== NOT EXECUTED
 2021624:	40 00 71 bc 	call  203dd14 <strncpy>                        <== NOT EXECUTED
 2021628:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
    rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);      
 202162c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2021630:	40 00 0e 78 	call  2025010 <rtems_mkdir>                    <== NOT EXECUTED
 2021634:	92 10 21 ff 	mov  0x1ff, %o1                                <== NOT EXECUTED
    if (rv != 0) {                                                    
 2021638:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 202163c:	12 80 00 13 	bne  2021688 <rtems_bdpart_mount+0x15c>        <== NOT EXECUTED
 2021640:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
 2021644:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2021648:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
 202164c:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
 2021650:	7f ff 88 96 	call  20038a8 <mount>                          <== NOT EXECUTED
 2021654:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
      mount_point,                                                    
      "msdos",                                                        
      0,                                                              
      NULL                                                            
    );                                                                
    if (rv != 0) {                                                    
 2021658:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 202165c:	02 80 00 05 	be  2021670 <rtems_bdpart_mount+0x144>         <== NOT EXECUTED
 2021660:	80 a7 00 1a 	cmp  %i4, %i2                                  <== NOT EXECUTED
      rmdir( mount_point);                                            
 2021664:	40 00 0e 43 	call  2024f70 <rmdir>                          <== NOT EXECUTED
 2021668:	90 10 00 1d 	mov  %i5, %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) {                                       
 202166c:	80 a7 00 1a 	cmp  %i4, %i2                                  <== NOT EXECUTED
 2021670:	32 bf ff e4 	bne,a   2021600 <rtems_bdpart_mount+0xd4>      <== NOT EXECUTED
 2021674:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
 2021678:	10 80 00 05 	b  202168c <rtems_bdpart_mount+0x160>          <== NOT EXECUTED
 202167c:	b8 10 20 00 	clr  %i4                                       <== 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;                                       
 2021680:	10 80 00 03 	b  202168c <rtems_bdpart_mount+0x160>          <== NOT EXECUTED
 2021684:	b8 10 20 03 	mov  3, %i4                                    <== 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;                                           
 2021688:	b8 10 20 1b 	mov  0x1b, %i4                                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
 202168c:	7f ff 87 2c 	call  200333c <free>                           <== NOT EXECUTED
 2021690:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
  free( mount_point);                                                 
 2021694:	7f ff 87 2a 	call  200333c <free>                           <== NOT EXECUTED
 2021698:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
 202169c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20216a0:	91 e8 00 1c 	restore  %g0, %i4, %o0                         <== NOT EXECUTED
                                                                      

02003804 <rtems_bdpart_new_record>: static rtems_status_code rtems_bdpart_new_record( rtems_disk_device *dd, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
 2003804:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Synchronize previous block if necessary */                       
  if (*block != NULL) {                                               
 2003808:	d0 06 80 00 	ld  [ %i2 ], %o0                               
 200380c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003810:	12 80 00 0b 	bne  200383c <rtems_bdpart_new_record+0x38>    
 2003814:	01 00 00 00 	nop                                            
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the new record block (this accounts for disk block sizes > 512) */
  sc = rtems_bdbuf_read( dd, index, block);                           
 2003818:	90 10 00 18 	mov  %i0, %o0                                  
 200381c:	92 10 00 19 	mov  %i1, %o1                                  
 2003820:	40 00 31 47 	call  200fd3c <rtems_bdbuf_read>               
 2003824:	94 10 00 1a 	mov  %i2, %o2                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003828:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200382c:	22 80 00 0b 	be,a   2003858 <rtems_bdpart_new_record+0x54>  <== ALWAYS TAKEN
 2003830:	c2 06 80 00 	ld  [ %i2 ], %g1                               
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003834:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003838:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Synchronize previous block if necessary */                       
  if (*block != NULL) {                                               
    sc = rtems_bdbuf_sync( *block);                                   
 200383c:	40 00 32 0e 	call  2010074 <rtems_bdbuf_sync>               
 2003840:	01 00 00 00 	nop                                            
    if (sc != RTEMS_SUCCESSFUL) {                                     
 2003844:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2003848:	02 bf ff f5 	be  200381c <rtems_bdpart_new_record+0x18>     <== ALWAYS TAKEN
 200384c:	90 10 00 18 	mov  %i0, %o0                                  
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003850:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003854:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
 2003858:	80 a0 60 00 	cmp  %g1, 0                                    
 200385c:	02 80 00 0e 	be  2003894 <rtems_bdpart_new_record+0x90>     <== NEVER TAKEN
 2003860:	92 10 20 00 	clr  %o1                                       
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Clear record */                                                  
  memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);              
 2003864:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 2003868:	40 00 47 bf 	call  2015764 <memset>                         
 200386c:	94 10 22 00 	mov  0x200, %o2                                
                                                                      
  /* Write signature */                                               
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =            
 2003870:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 2003874:	84 10 20 55 	mov  0x55, %g2                                 
 2003878:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 200387c:	c4 28 61 fe 	stb  %g2, [ %g1 + 0x1fe ]                      
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
 2003880:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 2003884:	84 10 3f aa 	mov  -86, %g2                                  
 2003888:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 200388c:	10 80 00 03 	b  2003898 <rtems_bdpart_new_record+0x94>      
 2003890:	c4 28 61 ff 	stb  %g2, [ %g1 + 0x1ff ]                      
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
    return RTEMS_INVALID_ADDRESS;                                     
 2003894:	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;                                            
}                                                                     
 2003898:	b0 10 00 1d 	mov  %i5, %i0                                  
 200389c:	81 c7 e0 08 	ret                                            
 20038a0:	81 e8 00 00 	restore                                        
                                                                      

020033c8 <rtems_bdpart_read>: const char *disk_name, rtems_bdpart_format *format, rtems_bdpart_partition *pt, size_t *count ) {
 20033c8:	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;                                 
 20033cc:	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;                                   
 20033d0:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
  rtems_bdpart_partition *p = pt - 1;                                 
 20033d4:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
 20033d8:	80 a6 e0 00 	cmp  %i3, 0                                    
 20033dc:	02 80 00 07 	be  20033f8 <rtems_bdpart_read+0x30>           <== NEVER TAKEN
 20033e0:	90 10 00 18 	mov  %i0, %o0                                  
 20033e4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 20033e8:	85 28 60 04 	sll  %g1, 4, %g2                               
 20033ec:	b9 28 60 06 	sll  %g1, 6, %i4                               
 20033f0:	10 80 00 03 	b  20033fc <rtems_bdpart_read+0x34>            
 20033f4:	b8 27 00 02 	sub  %i4, %g2, %i4                             
 20033f8:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  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;                                                        
 20033fc:	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 */      
 2003400:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */   
  rtems_blkdev_bnum disk_end = 0;                                     
 2003404:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t i = 0;                                                       
  const uint8_t *data = NULL;                                         
  int fd = -1;                                                        
 2003408:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
 200340c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || count == NULL) {                
 2003410:	80 a6 a0 00 	cmp  %i2, 0                                    
 2003414:	02 80 00 89 	be  2003638 <rtems_bdpart_read+0x270>          <== NEVER TAKEN
 2003418:	b0 10 20 09 	mov  9, %i0                                    
 200341c:	80 a6 60 00 	cmp  %i1, 0                                    
 2003420:	02 80 00 86 	be  2003638 <rtems_bdpart_read+0x270>          <== NEVER TAKEN
 2003424:	80 a6 e0 00 	cmp  %i3, 0                                    
 2003428:	02 80 00 84 	be  2003638 <rtems_bdpart_read+0x270>          <== NEVER TAKEN
 200342c:	92 07 bf f8 	add  %fp, -8, %o1                              
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Set count to a save value */                                     
  *count = 0;                                                         
 2003430:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
 2003434:	94 07 bf fc 	add  %fp, -4, %o2                              
 2003438:	7f ff ff bb 	call  2003324 <rtems_bdpart_get_disk_data>     
 200343c:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003440:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003444:	12 80 00 7d 	bne  2003638 <rtems_bdpart_read+0x270>         <== NEVER TAKEN
 2003448:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
    return sc;                                                        
  }                                                                   
                                                                      
  /* Read MBR */                                                      
  sc = rtems_bdpart_read_record( dd, 0, &block);                      
 200344c:	92 10 20 00 	clr  %o1                                       
 2003450:	7f ff ff 4d 	call  2003184 <rtems_bdpart_read_record>       
 2003454:	94 07 bf e8 	add  %fp, -24, %o2                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003458:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200345c:	12 80 00 6c 	bne  200360c <rtems_bdpart_read+0x244>         <== NEVER TAKEN
 2003460:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
 2003464:	c2 07 bf e8 	ld  [ %fp + -24 ], %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);
 2003468:	b8 06 80 1c 	add  %i2, %i4, %i4                             
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
 200346c:	e4 00 60 1c 	ld  [ %g1 + 0x1c ], %l2                        
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);  
 2003470:	a2 07 bf ec 	add  %fp, -20, %l1                             
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Read the first partition entry */                                
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;             
 2003474:	ba 04 a1 be 	add  %l2, 0x1be, %i5                           
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);  
 2003478:	a0 07 bf f0 	add  %fp, -16, %l0                             
 200347c:	90 10 00 1d 	mov  %i5, %o0                                  
 2003480:	92 10 00 11 	mov  %l1, %o1                                  
 2003484:	94 10 00 1c 	mov  %i4, %o2                                  
 2003488:	7f ff ff 70 	call  2003248 <rtems_bdpart_read_mbr_partition>
 200348c:	96 10 00 10 	mov  %l0, %o3                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003490:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003494:	32 80 00 5e 	bne,a   200360c <rtems_bdpart_read+0x244>      <== NEVER TAKEN
 2003498:	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) {
 200349c:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
 20034a0:	c2 08 60 08 	ldub  [ %g1 + 8 ], %g1                         
 20034a4:	80 a0 60 ee 	cmp  %g1, 0xee                                 
 20034a8:	02 80 00 58 	be  2003608 <rtems_bdpart_read+0x240>          <== NEVER TAKEN
 20034ac:	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                   
 20034b0:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
    esc = RTEMS_NOT_IMPLEMENTED;                                      
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
 20034b4:	c0 26 40 00 	clr  [ %i1 ]                                   
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
 20034b8:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_read(                                  
 20034bc:	a4 04 a1 ee 	add  %l2, 0x1ee, %l2                           
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
 20034c0:	7f ff ff 26 	call  2003158 <rtems_uint32_from_little_endian>
 20034c4:	90 02 21 b8 	add  %o0, 0x1b8, %o0                           
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
 20034c8:	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(              
 20034cc:	d0 26 60 04 	st  %o0, [ %i1 + 4 ]                           
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
 20034d0:	c2 2e 60 08 	stb  %g1, [ %i1 + 8 ]                          
                                                                      
  /* Iterate through the rest of the primary partition table */       
  for (i = 1; i < 4; ++i) {                                           
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
 20034d4:	ba 07 60 10 	add  %i5, 0x10, %i5                            
                                                                      
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
 20034d8:	92 10 00 11 	mov  %l1, %o1                                  
 20034dc:	90 10 00 1d 	mov  %i5, %o0                                  
 20034e0:	94 10 00 1c 	mov  %i4, %o2                                  
 20034e4:	7f ff ff 59 	call  2003248 <rtems_bdpart_read_mbr_partition>
 20034e8:	96 10 00 10 	mov  %l0, %o3                                  
    if (sc != RTEMS_SUCCESSFUL) {                                     
 20034ec:	80 a2 20 00 	cmp  %o0, 0                                    
 20034f0:	12 80 00 45 	bne  2003604 <rtems_bdpart_read+0x23c>         <== NEVER TAKEN
 20034f4:	80 a7 40 12 	cmp  %i5, %l2                                  
    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) {                                           
 20034f8:	32 bf ff f8 	bne,a   20034d8 <rtems_bdpart_read+0x110>      
 20034fc:	ba 07 60 10 	add  %i5, 0x10, %i5                            
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
  while (ebr != 0) {                                                  
 2003500:	10 80 00 2e 	b  20035b8 <rtems_bdpart_read+0x1f0>           
 2003504:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5                         
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( dd, ebr, &block);                  
 2003508:	92 10 00 1d 	mov  %i5, %o1                                  
 200350c:	7f ff ff 1e 	call  2003184 <rtems_bdpart_read_record>       
 2003510:	94 07 bf e8 	add  %fp, -24, %o2                             
    if (sc != RTEMS_SUCCESSFUL) {                                     
 2003514:	80 a2 20 00 	cmp  %o0, 0                                    
 2003518:	12 80 00 3b 	bne  2003604 <rtems_bdpart_read+0x23c>         <== NEVER TAKEN
 200351c:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
 2003520:	92 10 00 11 	mov  %l1, %o1                                  
 2003524:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 2003528:	94 10 00 1c 	mov  %i4, %o2                                  
 200352c:	90 02 21 be 	add  %o0, 0x1be, %o0                           
 2003530:	7f ff ff 46 	call  2003248 <rtems_bdpart_read_mbr_partition>
 2003534:	96 10 20 00 	clr  %o3                                       
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                
      &p,                                                             
      p_end,                                                          
      NULL                                                            
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
 2003538:	80 a2 20 00 	cmp  %o0, 0                                    
 200353c:	12 80 00 32 	bne  2003604 <rtems_bdpart_read+0x23c>         <== NEVER TAKEN
 2003540:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition begin */                                      
    tmp = p->begin + ebr;                                             
 2003544:	c6 00 40 00 	ld  [ %g1 ], %g3                               
 2003548:	84 07 40 03 	add  %i5, %g3, %g2                             
    if (tmp > p->begin) {                                             
 200354c:	80 a0 80 03 	cmp  %g2, %g3                                  
 2003550:	38 80 00 04 	bgu,a   2003560 <rtems_bdpart_read+0x198>      <== ALWAYS TAKEN
 2003554:	c4 20 40 00 	st  %g2, [ %g1 ]                               
      p->begin = tmp;                                                 
    } else {                                                          
      esc = RTEMS_IO_ERROR;                                           
 2003558:	10 80 00 2c 	b  2003608 <rtems_bdpart_read+0x240>           <== NOT EXECUTED
 200355c:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
 2003560:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
 2003564:	ba 07 40 02 	add  %i5, %g2, %i5                             
    if (tmp > p->end) {                                               
 2003568:	80 a7 40 02 	cmp  %i5, %g2                                  
 200356c:	08 80 00 27 	bleu  2003608 <rtems_bdpart_read+0x240>        <== NEVER TAKEN
 2003570:	b0 10 20 1b 	mov  0x1b, %i0                                 
      p->end = tmp;                                                   
 2003574:	fa 20 60 04 	st  %i5, [ %g1 + 4 ]                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                 
 2003578:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
 200357c:	f2 00 60 1c 	ld  [ %g1 + 0x1c ], %i1                        
      == RTEMS_BDPART_MBR_SIGNATURE_1;                                
}                                                                     
                                                                      
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)  
{                                                                     
  rtems_blkdev_bnum begin =                                           
 2003580:	7f ff fe f6 	call  2003158 <rtems_uint32_from_little_endian>
 2003584:	90 06 61 d6 	add  %i1, 0x1d6, %o0                           
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];                 
                                                                      
  if (type == RTEMS_BDPART_MBR_EXTENDED) {                            
 2003588:	c2 0e 61 d2 	ldub  [ %i1 + 0x1d2 ], %g1                     
 200358c:	80 a0 60 05 	cmp  %g1, 5                                    
 2003590:	12 80 00 0e 	bne  20035c8 <rtems_bdpart_read+0x200>         
 2003594:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
                                                                      
    /* Read second partition entry for next EBR block */              
    ebr = rtems_bdpart_next_ebr(                                      
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                 
    );                                                                
    if (ebr != 0) {                                                   
 2003598:	80 a2 20 00 	cmp  %o0, 0                                    
 200359c:	02 80 00 0a 	be  20035c4 <rtems_bdpart_read+0x1fc>          <== NEVER TAKEN
 20035a0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
      /* Adjust partition EBR block index */                          
      tmp = ebr + ep_begin;                                           
 20035a4:	82 02 00 01 	add  %o0, %g1, %g1                             
      if (tmp > ebr) {                                                
 20035a8:	80 a0 40 08 	cmp  %g1, %o0                                  
 20035ac:	08 80 00 17 	bleu  2003608 <rtems_bdpart_read+0x240>        <== NEVER TAKEN
 20035b0:	b0 10 20 1b 	mov  0x1b, %i0                                 
 20035b4:	ba 10 00 01 	mov  %g1, %i5                                  
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
  while (ebr != 0) {                                                  
 20035b8:	80 a7 60 00 	cmp  %i5, 0                                    
 20035bc:	12 bf ff d3 	bne  2003508 <rtems_bdpart_read+0x140>         <== ALWAYS TAKEN
 20035c0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
 20035c4:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         <== NOT EXECUTED
  rtems_bdpart_partition *pt,                                         
  size_t *count                                                       
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
 20035c8:	b0 10 20 00 	clr  %i0                                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
 20035cc:	b4 20 40 1a 	sub  %g1, %i2, %i2                             
 20035d0:	b5 3e a0 04 	sra  %i2, 4, %i2                               
 20035d4:	83 2e a0 02 	sll  %i2, 2, %g1                               
 20035d8:	82 00 40 1a 	add  %g1, %i2, %g1                             
 20035dc:	85 28 60 04 	sll  %g1, 4, %g2                               
 20035e0:	82 00 40 02 	add  %g1, %g2, %g1                             
 20035e4:	85 28 60 08 	sll  %g1, 8, %g2                               
 20035e8:	82 00 40 02 	add  %g1, %g2, %g1                             
 20035ec:	85 28 60 10 	sll  %g1, 0x10, %g2                            
 20035f0:	82 00 40 02 	add  %g1, %g2, %g1                             
 20035f4:	82 20 00 01 	neg  %g1                                       
 20035f8:	82 00 60 01 	inc  %g1                                       
 20035fc:	10 80 00 03 	b  2003608 <rtems_bdpart_read+0x240>           
 2003600:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
 2003604:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
                                                                      
cleanup:                                                              
                                                                      
  if (fd >= 0) {                                                      
 2003608:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
 200360c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003610:	26 80 00 05 	bl,a   2003624 <rtems_bdpart_read+0x25c>       <== NEVER TAKEN
 2003614:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0                         <== NOT EXECUTED
    close( fd);                                                       
 2003618:	40 00 07 df 	call  2005594 <close>                          
 200361c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if (block != NULL) {                                                
 2003620:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0                         
 2003624:	80 a2 20 00 	cmp  %o0, 0                                    
 2003628:	02 80 00 06 	be  2003640 <rtems_bdpart_read+0x278>          <== NEVER TAKEN
 200362c:	01 00 00 00 	nop                                            
    rtems_bdbuf_release( block);                                      
 2003630:	40 00 32 3f 	call  200ff2c <rtems_bdbuf_release>            
 2003634:	01 00 00 00 	nop                                            
 2003638:	81 c7 e0 08 	ret                                            
 200363c:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
 2003640:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003644:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003248 <rtems_bdpart_read_mbr_partition>: const uint8_t *data, rtems_bdpart_partition **p, const rtems_bdpart_partition *p_end, rtems_blkdev_bnum *ep_begin ) {
 2003248:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_blkdev_bnum begin =                                           
 200324c:	7f ff ff c3 	call  2003158 <rtems_uint32_from_little_endian>
 2003250:	90 06 20 08 	add  %i0, 8, %o0                               
 2003254:	ba 10 00 08 	mov  %o0, %i5                                  
    rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
  rtems_blkdev_bnum size =                                            
 2003258:	7f ff ff c0 	call  2003158 <rtems_uint32_from_little_endian>
 200325c:	90 06 20 0c 	add  %i0, 0xc, %o0                             
    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) {                               
 2003260:	f8 0e 20 04 	ldub  [ %i0 + 4 ], %i4                         
 2003264:	80 a7 20 00 	cmp  %i4, 0                                    
 2003268:	02 80 00 21 	be  20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
 200326c:	82 10 20 00 	clr  %g1                                       
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
 2003270:	c4 06 40 00 	ld  [ %i1 ], %g2                               
 2003274:	80 a0 80 1a 	cmp  %g2, %i2                                  
 2003278:	02 80 00 1d 	be  20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
 200327c:	82 10 20 05 	mov  5, %g1                                    
{                                                                     
  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;                               
 2003280:	b4 02 00 1d 	add  %o0, %i5, %i2                             
                                                                      
  if (type == RTEMS_BDPART_MBR_EMPTY) {                               
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
    return RTEMS_TOO_MANY;                                            
  } else if (begin >= end) {                                          
 2003284:	80 a7 40 1a 	cmp  %i5, %i2                                  
 2003288:	1a 80 00 19 	bcc  20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
 200328c:	82 10 20 1b 	mov  0x1b, %g1                                 
    return RTEMS_IO_ERROR;                                            
  } else if (type == RTEMS_BDPART_MBR_EXTENDED) {                     
 2003290:	80 a7 20 05 	cmp  %i4, 5                                    
 2003294:	32 80 00 07 	bne,a   20032b0 <rtems_bdpart_read_mbr_partition+0x68>
 2003298:	90 00 a0 30 	add  %g2, 0x30, %o0                            
    if (ep_begin != NULL) {                                           
 200329c:	80 a6 e0 00 	cmp  %i3, 0                                    
 20032a0:	32 80 00 12 	bne,a   20032e8 <rtems_bdpart_read_mbr_partition+0xa0><== ALWAYS TAKEN
 20032a4:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
    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) {                               
    return RTEMS_SUCCESSFUL;                                          
 20032a8:	10 80 00 11 	b  20032ec <rtems_bdpart_read_mbr_partition+0xa4><== NOT EXECUTED
 20032ac:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
  } else {                                                            
    /* Increment partition index */                                   
    ++(*p);                                                           
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
 20032b0:	92 10 20 00 	clr  %o1                                       
 20032b4:	94 10 20 30 	mov  0x30, %o2                                 
 20032b8:	40 00 49 2b 	call  2015764 <memset>                         
 20032bc:	d0 26 40 00 	st  %o0, [ %i1 ]                               
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
 20032c0:	d2 06 40 00 	ld  [ %i1 ], %o1                               
    (*p)->end = end;                                                  
    rtems_bdpart_to_partition_type( type, (*p)->type);                
 20032c4:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
 20032c8:	fa 22 40 00 	st  %i5, [ %o1 ]                               
    (*p)->end = end;                                                  
 20032cc:	f4 22 60 04 	st  %i2, [ %o1 + 4 ]                           
    rtems_bdpart_to_partition_type( type, (*p)->type);                
 20032d0:	7f ff ff d6 	call  2003228 <rtems_bdpart_to_partition_type> 
 20032d4:	92 02 60 08 	add  %o1, 8, %o1                               
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
 20032d8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 20032dc:	c4 0e 00 00 	ldub  [ %i0 ], %g2                             
 20032e0:	c0 20 60 28 	clr  [ %g1 + 0x28 ]                            
 20032e4:	c4 20 60 2c 	st  %g2, [ %g1 + 0x2c ]                        
    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) {                               
    return RTEMS_SUCCESSFUL;                                          
 20032e8:	82 10 20 00 	clr  %g1                                       
    rtems_bdpart_to_partition_type( type, (*p)->type);                
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20032ec:	81 c7 e0 08 	ret                                            
 20032f0:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02003184 <rtems_bdpart_read_record>: static rtems_status_code rtems_bdpart_read_record( rtems_disk_device *dd, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
 2003184:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Release previous block if necessary */                           
  if (*block != NULL) {                                               
 2003188:	d0 06 80 00 	ld  [ %i2 ], %o0                               
 200318c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003190:	12 80 00 0b 	bne  20031bc <rtems_bdpart_read_record+0x38>   
 2003194:	01 00 00 00 	nop                                            
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the record block */                                         
  sc = rtems_bdbuf_read( dd, index, block);                           
 2003198:	90 10 00 18 	mov  %i0, %o0                                  
 200319c:	92 10 00 19 	mov  %i1, %o1                                  
 20031a0:	40 00 32 e7 	call  200fd3c <rtems_bdbuf_read>               
 20031a4:	94 10 00 1a 	mov  %i2, %o2                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 20031a8:	80 a2 20 00 	cmp  %o0, 0                                    
 20031ac:	22 80 00 0b 	be,a   20031d8 <rtems_bdpart_read_record+0x54> <== ALWAYS TAKEN
 20031b0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20031b4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20031b8:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Release previous block if necessary */                           
  if (*block != NULL) {                                               
    sc = rtems_bdbuf_release( *block);                                
 20031bc:	40 00 33 5c 	call  200ff2c <rtems_bdbuf_release>            
 20031c0:	01 00 00 00 	nop                                            
    if (sc != RTEMS_SUCCESSFUL) {                                     
 20031c4:	80 a2 20 00 	cmp  %o0, 0                                    
 20031c8:	22 bf ff f5 	be,a   200319c <rtems_bdpart_read_record+0x18> <== ALWAYS TAKEN
 20031cc:	90 10 00 18 	mov  %i0, %o0                                  
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20031d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20031d4:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
 20031d8:	80 a0 60 00 	cmp  %g1, 0                                    
 20031dc:	22 80 00 10 	be,a   200321c <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
 20031e0:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
 20031e4:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        
                                                                      
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]                     
 20031e8:	c6 08 a1 fe 	ldub  [ %g2 + 0x1fe ], %g3                     
 20031ec:	80 a0 e0 55 	cmp  %g3, 0x55                                 
 20031f0:	12 80 00 06 	bne  2003208 <rtems_bdpart_read_record+0x84>   <== NEVER TAKEN
 20031f4:	82 10 20 00 	clr  %g1                                       
 20031f8:	c2 08 a1 ff 	ldub  [ %g2 + 0x1ff ], %g1                     
 20031fc:	82 18 60 aa 	xor  %g1, 0xaa, %g1                            
 2003200:	80 a0 00 01 	cmp  %g0, %g1                                  
 2003204:	82 60 3f ff 	subx  %g0, -1, %g1                             
  if ( *block == NULL ) {                                             
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
 2003208:	80 a0 60 00 	cmp  %g1, 0                                    
 200320c:	22 80 00 04 	be,a   200321c <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
 2003210:	90 10 20 1b 	mov  0x1b, %o0                                 <== NOT EXECUTED
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003214:	81 c7 e0 08 	ret                                            
 2003218:	91 e8 00 08 	restore  %g0, %o0, %o0                         
 200321c:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
 2003220:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003224:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003648 <rtems_bdpart_register>: rtems_status_code rtems_bdpart_register( const char *disk_name, const rtems_bdpart_partition *pt, size_t count ) {
 2003648:	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);                         
 200364c:	90 10 00 18 	mov  %i0, %o0                                  
 2003650:	40 00 4c 24 	call  20166e0 <strlen>                         
 2003654:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
 2003658:	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                                                        
)                                                                     
{                                                                     
 200365c:	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);                         
 2003660:	a0 10 00 08 	mov  %o0, %l0                                  
  size_t i = 0;                                                       
  int fd = -1;                                                        
 2003664:	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);   
 2003668:	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;                                       
 200366c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
 2003670:	92 07 bf f8 	add  %fp, -8, %o1                              
 2003674:	94 07 bf fc 	add  %fp, -4, %o2                              
 2003678:	7f ff ff 2b 	call  2003324 <rtems_bdpart_get_disk_data>     
 200367c:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003680:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003684:	12 80 00 31 	bne  2003748 <rtems_bdpart_register+0x100>     <== NEVER TAKEN
 2003688:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return sc;                                                        
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
 200368c:	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;                                                     
 2003690:	e2 00 40 00 	ld  [ %g1 ], %l1                               
 2003694:	40 00 07 c0 	call  2005594 <close>                          
 2003698:	f6 00 60 04 	ld  [ %g1 + 4 ], %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);
 200369c:	90 04 20 04 	add  %l0, 4, %o0                               
 20036a0:	40 00 0a 0b 	call  2005ecc <malloc>                         
 20036a4:	b0 10 20 1a 	mov  0x1a, %i0                                 
  if (logical_disk_name == NULL) {                                    
 20036a8:	80 a2 20 00 	cmp  %o0, 0                                    
 20036ac:	02 80 00 27 	be  2003748 <rtems_bdpart_register+0x100>      <== NEVER TAKEN
 20036b0:	b8 10 00 08 	mov  %o0, %i4                                  
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
 20036b4:	92 10 00 1d 	mov  %i5, %o1                                  
 20036b8:	94 10 00 10 	mov  %l0, %o2                                  
 20036bc:	40 00 4c 91 	call  2016900 <strncpy>                        
 20036c0:	25 00 80 90 	sethi  %hi(0x2024000), %l2                     
  logical_disk_marker = logical_disk_name + disk_name_size;           
 20036c4:	a0 07 00 10 	add  %i4, %l0, %l0                             
#include <string.h>                                                   
                                                                      
#include <rtems.h>                                                    
#include <rtems/bdpart.h>                                             
                                                                      
rtems_status_code rtems_bdpart_register(                              
 20036c8:	b4 06 80 1b 	add  %i2, %i3, %i2                             
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
 20036cc:	ba 10 00 1b 	mov  %i3, %i5                                  
  }                                                                   
  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) {                                       
 20036d0:	10 80 00 16 	b  2003728 <rtems_bdpart_register+0xe0>        
 20036d4:	a4 14 a3 00 	or  %l2, 0x300, %l2                            
                                                                      
    /* 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);
 20036d8:	90 10 00 10 	mov  %l0, %o0                                  
 20036dc:	92 10 20 04 	mov  4, %o1                                    
 20036e0:	94 10 00 12 	mov  %l2, %o2                                  
 20036e4:	40 00 49 62 	call  2015c6c <snprintf>                       
 20036e8:	96 27 40 1b 	sub  %i5, %i3, %o3                             
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
 20036ec:	80 a2 20 03 	cmp  %o0, 3                                    
 20036f0:	14 80 00 13 	bg  200373c <rtems_bdpart_register+0xf4>       <== NEVER TAKEN
 20036f4:	90 10 00 11 	mov  %l1, %o0                                  
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
 20036f8:	da 06 60 04 	ld  [ %i1 + 4 ], %o5                           
      logical_disk,                                                   
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
 20036fc:	d8 06 40 00 	ld  [ %i1 ], %o4                               
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
 2003700:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        
 2003704:	92 10 00 1d 	mov  %i5, %o1                                  
 2003708:	94 10 00 11 	mov  %l1, %o2                                  
 200370c:	96 10 00 1b 	mov  %i3, %o3                                  
 2003710:	9a 23 40 0c 	sub  %o5, %o4, %o5                             
 2003714:	40 00 03 1e 	call  200438c <rtems_disk_create_log>          
 2003718:	b2 06 60 30 	add  %i1, 0x30, %i1                            
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      logical_disk_name                                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
 200371c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003720:	12 80 00 08 	bne  2003740 <rtems_bdpart_register+0xf8>      <== NEVER TAKEN
 2003724:	b0 10 00 08 	mov  %o0, %i0                                  
  }                                                                   
  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) {                                       
 2003728:	80 a7 40 1a 	cmp  %i5, %i2                                  
 200372c:	32 bf ff eb 	bne,a   20036d8 <rtems_bdpart_register+0x90>   
 2003730:	ba 07 60 01 	inc  %i5                                       
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
 2003734:	10 80 00 03 	b  2003740 <rtems_bdpart_register+0xf8>        
 2003738:	b0 10 20 00 	clr  %i0                                       
 200373c:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
 2003740:	40 00 08 52 	call  2005888 <free>                           
 2003744:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  return esc;                                                         
}                                                                     
 2003748:	81 c7 e0 08 	ret                                            
 200374c:	81 e8 00 00 	restore                                        
                                                                      

02003750 <rtems_bdpart_register_from_disk>: rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name) {
 2003750:	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;                  
 2003754:	82 10 20 10 	mov  0x10, %g1                                 
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
 2003758:	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;                  
 200375c:	c2 27 bc e8 	st  %g1, [ %fp + -792 ]                        
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
 2003760:	92 07 bc ec 	add  %fp, -788, %o1                            
 2003764:	94 07 bd 00 	add  %fp, -768, %o2                            
 2003768:	7f ff ff 18 	call  20033c8 <rtems_bdpart_read>              
 200376c:	96 07 bc e8 	add  %fp, -792, %o3                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003770:	80 a2 20 00 	cmp  %o0, 0                                    
 2003774:	12 80 00 05 	bne  2003788 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
 2003778:	d4 07 bc e8 	ld  [ %fp + -792 ], %o2                        
    return sc;                                                        
  }                                                                   
                                                                      
  /* Register partitions */                                           
  return rtems_bdpart_register( disk_name, pt, count);                
 200377c:	90 10 00 18 	mov  %i0, %o0                                  
 2003780:	7f ff ff b2 	call  2003648 <rtems_bdpart_register>          
 2003784:	92 07 bd 00 	add  %fp, -768, %o1                            
}                                                                     
 2003788:	81 c7 e0 08 	ret                                            
 200378c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020216a4 <rtems_bdpart_unmount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
 20216a4:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
 20216a8:	92 10 20 2f 	mov  0x2f, %o1                                 <== NOT EXECUTED
 20216ac:	40 00 75 01 	call  203eab0 <strrchr>                        <== NOT EXECUTED
 20216b0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 20216b4:	b2 10 00 08 	mov  %o0, %i1                                  <== 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);                         
 20216b8:	40 00 70 db 	call  203da24 <strlen>                         <== NOT EXECUTED
 20216bc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 20216c0:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
 20216c4:	40 00 70 d8 	call  203da24 <strlen>                         <== NOT EXECUTED
 20216c8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
 20216cc:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
 20216d0:	02 80 00 07 	be  20216ec <rtems_bdpart_unmount+0x48>        <== NOT EXECUTED
 20216d4:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
    disk_file_name += 1;                                              
 20216d8:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
 20216dc:	40 00 70 d2 	call  203da24 <strlen>                         <== NOT EXECUTED
 20216e0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 20216e4:	10 80 00 03 	b  20216f0 <rtems_bdpart_unmount+0x4c>         <== NOT EXECUTED
 20216e8:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  } else {                                                            
    disk_file_name = disk_name;                                       
 20216ec:	b2 10 00 18 	mov  %i0, %i1                                  <== NOT EXECUTED
    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);
 20216f0:	a2 04 00 1c 	add  %l0, %i4, %l1                             <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
 20216f4:	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);
 20216f8:	7f ff 87 e5 	call  200368c <malloc>                         <== NOT EXECUTED
 20216fc:	90 04 60 05 	add  %l1, 5, %o0                               <== NOT EXECUTED
  if (mount_point == NULL) {                                          
 2021700:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2021704:	02 80 00 28 	be  20217a4 <rtems_bdpart_unmount+0x100>       <== NOT EXECUTED
 2021708:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
 202170c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 2021710:	40 00 71 81 	call  203dd14 <strncpy>                        <== NOT EXECUTED
 2021714:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
 2021718:	82 10 20 2f 	mov  0x2f, %g1                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
 202171c:	90 07 20 01 	add  %i4, 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] = '/';                                
 2021720:	c2 2f 40 1c 	stb  %g1, [ %i5 + %i4 ]                        <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
 2021724:	90 07 40 08 	add  %i5, %o0, %o0                             <== NOT EXECUTED
 2021728:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 202172c:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
 2021730:	a2 04 60 01 	inc  %l1                                       <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
  mount_point [mount_base_size] = '/';                                
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
 2021734:	40 00 71 78 	call  203dd14 <strncpy>                        <== NOT EXECUTED
 2021738:	37 00 81 68 	sethi  %hi(0x205a000), %i3                     <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
 202173c:	a2 07 40 11 	add  %i5, %l1, %l1                             <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
 2021740:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
 2021744:	10 80 00 14 	b  2021794 <rtems_bdpart_unmount+0xf0>         <== NOT EXECUTED
 2021748:	b6 16 e0 c0 	or  %i3, 0xc0, %i3                             <== NOT EXECUTED
    /* Create mount point */                                          
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
 202174c:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
 2021750:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 2021754:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
 2021758:	40 00 6d 15 	call  203cbac <snprintf>                       <== NOT EXECUTED
 202175c:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
 2021760:	80 a2 20 03 	cmp  %o0, 3                                    <== NOT EXECUTED
 2021764:	14 80 00 10 	bg  20217a4 <rtems_bdpart_unmount+0x100>       <== NOT EXECUTED
 2021768:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Unmount */                                                     
    rv = unmount( mount_point);                                       
 202176c:	40 00 0f a9 	call  2025610 <unmount>                        <== NOT EXECUTED
 2021770:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    if (rv == 0) {                                                    
 2021774:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2021778:	12 80 00 08 	bne  2021798 <rtems_bdpart_unmount+0xf4>       <== NOT EXECUTED
 202177c:	80 a7 00 1a 	cmp  %i4, %i2                                  <== NOT EXECUTED
      /* Remove mount point */                                        
      rv = rmdir( mount_point);                                       
 2021780:	40 00 0d fc 	call  2024f70 <rmdir>                          <== NOT EXECUTED
 2021784:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      if (rv != 0) {                                                  
 2021788:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 202178c:	12 80 00 06 	bne  20217a4 <rtems_bdpart_unmount+0x100>      <== NOT EXECUTED
 2021790:	b0 10 20 1b 	mov  0x1b, %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) {                                       
 2021794:	80 a7 00 1a 	cmp  %i4, %i2                                  <== NOT EXECUTED
 2021798:	32 bf ff ed 	bne,a   202174c <rtems_bdpart_unmount+0xa8>    <== NOT EXECUTED
 202179c:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
 20217a0:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
 20217a4:	7f ff 86 e6 	call  200333c <free>                           <== NOT EXECUTED
 20217a8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
 20217ac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20217b0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003790 <rtems_bdpart_unregister>: rtems_status_code rtems_bdpart_unregister( const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count ) {
 2003790:	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;                                                        
 2003794:	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);   
 2003798:	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;                                     
 200379c:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
 20037a0:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
 20037a4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
 20037a8:	92 07 bf f8 	add  %fp, -8, %o1                              
 20037ac:	94 07 bf fc 	add  %fp, -4, %o2                              
 20037b0:	7f ff fe dd 	call  2003324 <rtems_bdpart_get_disk_data>     
 20037b4:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
 20037b8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20037bc:	12 80 00 10 	bne  20037fc <rtems_bdpart_unregister+0x6c>    <== NEVER TAKEN
 20037c0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return sc;                                                        
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
 20037c4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
 20037c8:	40 00 07 73 	call  2005594 <close>                          
 20037cc:	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) {                                       
 20037d0:	10 80 00 08 	b  20037f0 <rtems_bdpart_unregister+0x60>      
 20037d4:	b4 06 80 1d 	add  %i2, %i5, %i2                             
                                                                      
    /* Get the device identifier */                                   
    logical_disk = rtems_filesystem_make_dev_t( major, minor);        
                                                                      
    /* Delete logical disk */                                         
    sc = rtems_disk_delete( logical_disk);                            
 20037d8:	90 10 00 1c 	mov  %i4, %o0                                  
 20037dc:	40 00 02 84 	call  20041ec <rtems_disk_delete>              
 20037e0:	92 10 00 1d 	mov  %i5, %o1                                  
    if (sc != RTEMS_SUCCESSFUL) {                                     
 20037e4:	80 a2 20 00 	cmp  %o0, 0                                    
 20037e8:	32 80 00 05 	bne,a   20037fc <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
 20037ec:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  /* Get the disk device identifier */                                
  rtems_filesystem_split_dev_t( disk, major, minor);                  
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
 20037f0:	80 a7 40 1a 	cmp  %i5, %i2                                  
 20037f4:	12 bf ff f9 	bne  20037d8 <rtems_bdpart_unregister+0x48>    
 20037f8:	ba 07 60 01 	inc  %i5                                       
 20037fc:	81 c7 e0 08 	ret                                            
 2003800:	81 e8 00 00 	restore                                        
                                                                      

020038e8 <rtems_bdpart_write>: const char *disk_name, const rtems_bdpart_format *format, const rtems_bdpart_partition *pt, size_t count ) {
 20038e8:	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;                                 
 20038ec:	80 a6 60 00 	cmp  %i1, 0                                    
 20038f0:	02 80 00 08 	be  2003910 <rtems_bdpart_write+0x28>          <== NEVER TAKEN
 20038f4:	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                        
 20038f8:	c4 06 40 00 	ld  [ %i1 ], %g2                               
 20038fc:	80 a0 a0 00 	cmp  %g2, 0                                    
 2003900:	12 80 00 05 	bne  2003914 <rtems_bdpart_write+0x2c>         <== NEVER TAKEN
 2003904:	82 10 20 00 	clr  %g1                                       
    && format->mbr.dos_compatibility;                                 
 2003908:	10 80 00 03 	b  2003914 <rtems_bdpart_write+0x2c>           
 200390c:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1                         
 2003910:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
 2003914:	a2 08 60 01 	and  %g1, 1, %l1                               
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
 2003918:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  rtems_blkdev_bnum disk_end = 0;                                     
  rtems_blkdev_bnum record_space =                                    
 200391c:	ba 0c 60 ff 	and  %l1, 0xff, %i5                            
    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;                                                        
 2003920:	82 10 3f ff 	mov  -1, %g1                                   
  bool dos_compatibility = format != NULL                             
    && 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 =                                    
 2003924:	80 a0 00 1d 	cmp  %g0, %i5                                  
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  bool dos_compatibility = format != NULL                             
    && format->type == RTEMS_BDPART_FORMAT_MBR                        
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
 2003928:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  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;                                                        
 200392c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
 2003930:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  bool dos_compatibility = format != NULL                             
    && 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 =                                    
 2003934:	b8 40 3f ff 	addx  %g0, -1, %i4                             
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
 2003938:	b0 10 20 00 	clr  %i0                                       
  bool dos_compatibility = format != NULL                             
    && 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 =                                    
 200393c:	b8 0f 3f c2 	and  %i4, -62, %i4                             
  uint8_t *data = NULL;                                               
  int fd = -1;                                                        
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
 2003940:	80 a6 e0 00 	cmp  %i3, 0                                    
 2003944:	02 80 00 cd 	be  2003c78 <rtems_bdpart_write+0x390>         <== NEVER TAKEN
 2003948:	b8 07 20 3f 	add  %i4, 0x3f, %i4                            
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL) {                                 
 200394c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2003950:	02 80 00 ca 	be  2003c78 <rtems_bdpart_write+0x390>         <== NEVER TAKEN
 2003954:	b0 10 20 09 	mov  9, %i0                                    
 2003958:	80 a6 60 00 	cmp  %i1, 0                                    
 200395c:	02 80 00 c7 	be  2003c78 <rtems_bdpart_write+0x390>         <== NEVER TAKEN
 2003960:	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);   
 2003964:	94 07 bf fc 	add  %fp, -4, %o2                              
 2003968:	7f ff fe 6f 	call  2003324 <rtems_bdpart_get_disk_data>     
 200396c:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003970:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003974:	12 80 00 c1 	bne  2003c78 <rtems_bdpart_write+0x390>        <== NEVER TAKEN
 2003978:	80 a7 60 00 	cmp  %i5, 0                                    
    return sc;                                                        
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
 200397c:	02 80 00 09 	be  20039a0 <rtems_bdpart_write+0xb8>          <== NEVER TAKEN
 2003980:	c8 07 bf f4 	ld  [ %fp + -12 ], %g4                         
    disk_end -= (disk_end % record_space);                            
 2003984:	fa 07 bf f4 	ld  [ %fp + -12 ], %i5                         
 2003988:	92 10 00 1c 	mov  %i4, %o1                                  
 200398c:	40 00 78 9d 	call  2021c00 <.urem>                          
 2003990:	90 10 00 1d 	mov  %i5, %o0                                  
 2003994:	90 27 40 08 	sub  %i5, %o0, %o0                             
 2003998:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
  /* 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) {                  
 200399c:	c8 07 bf f4 	ld  [ %fp + -12 ], %g4                         
 20039a0:	a0 10 00 1a 	mov  %i2, %l0                                  
 20039a4:	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) {                                       
 20039a8:	84 10 20 00 	clr  %g2                                       
    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) {                  
 20039ac:	c6 00 40 00 	ld  [ %g1 ], %g3                               
 20039b0:	80 a0 c0 04 	cmp  %g3, %g4                                  
 20039b4:	3a 80 00 a5 	bcc,a   2003c48 <rtems_bdpart_write+0x360>     <== NEVER TAKEN
 20039b8:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
 20039bc:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
 20039c0:	80 a7 40 04 	cmp  %i5, %g4                                  
 20039c4:	18 80 00 9e 	bgu  2003c3c <rtems_bdpart_write+0x354>        <== NEVER TAKEN
 20039c8:	80 a0 c0 1d 	cmp  %g3, %i5                                  
      esc = RTEMS_INVALID_NUMBER;                                     
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check that begin and end are valid */                          
    if (p->begin >= p->end) {                                         
 20039cc:	1a 80 00 9c 	bcc  2003c3c <rtems_bdpart_write+0x354>        <== NEVER TAKEN
 20039d0:	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) {                         
 20039d4:	02 80 00 06 	be  20039ec <rtems_bdpart_write+0x104>         
 20039d8:	84 00 a0 01 	inc  %g2                                       
 20039dc:	fa 00 7f d4 	ld  [ %g1 + -44 ], %i5                         
 20039e0:	80 a7 40 03 	cmp  %i5, %g3                                  
 20039e4:	38 80 00 99 	bgu,a   2003c48 <rtems_bdpart_write+0x360>     <== NEVER TAKEN
 20039e8:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
  if (dos_compatibility) {                                            
    disk_end -= (disk_end % record_space);                            
  }                                                                   
                                                                      
  /* Check that we have a consistent partition table */               
  for (i = 0; i < count; ++i) {                                       
 20039ec:	80 a0 80 1b 	cmp  %g2, %i3                                  
 20039f0:	12 bf ff ef 	bne  20039ac <rtems_bdpart_write+0xc4>         
 20039f4:	82 00 60 30 	add  %g1, 0x30, %g1                            
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
 20039f8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 20039fc:	80 a0 60 00 	cmp  %g1, 0                                    
 2003a00:	12 80 00 92 	bne  2003c48 <rtems_bdpart_write+0x360>        <== NEVER TAKEN
 2003a04:	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;                                       
 2003a08:	80 a6 e0 04 	cmp  %i3, 4                                    
 2003a0c:	08 80 00 03 	bleu  2003a18 <rtems_bdpart_write+0x130>       <== NEVER TAKEN
 2003a10:	ba 10 00 1b 	mov  %i3, %i5                                  
 2003a14:	ba 10 20 03 	mov  3, %i5                                    
                                                                      
  /*                                                                  
   * 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) {
 2003a18:	80 8c 60 ff 	btst  0xff, %l1                                
 2003a1c:	32 80 00 09 	bne,a   2003a40 <rtems_bdpart_write+0x158>     <== ALWAYS TAKEN
 2003a20:	c2 06 80 00 	ld  [ %i2 ], %g1                               
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
 2003a24:	83 2f 60 04 	sll  %i5, 4, %g1                               <== NOT EXECUTED
 2003a28:	a5 2f 60 06 	sll  %i5, 6, %l2                               
 2003a2c:	84 10 00 1d 	mov  %i5, %g2                                  
 2003a30:	a4 24 80 01 	sub  %l2, %g1, %l2                             
 2003a34:	82 10 20 00 	clr  %g1                                       
 2003a38:	10 80 00 0e 	b  2003a70 <rtems_bdpart_write+0x188>          
 2003a3c:	a2 06 80 12 	add  %i2, %l2, %l1                             
                                                                      
  /*                                                                  
   * 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) {
 2003a40:	80 a0 60 3f 	cmp  %g1, 0x3f                                 
 2003a44:	12 80 00 81 	bne  2003c48 <rtems_bdpart_write+0x360>        <== NEVER TAKEN
 2003a48:	b0 10 20 0a 	mov  0xa, %i0                                  
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
 2003a4c:	10 bf ff f7 	b  2003a28 <rtems_bdpart_write+0x140>          
 2003a50:	83 2f 60 04 	sll  %i5, 4, %g1                               
   * The space for the EBR and maybe some space which is needed for DOS
   * compatibility resides between the partitions.  So there have to be gaps of
   * the appropriate size between the partitions.                     
   */                                                                 
  for (i = ppc; i < count; ++i) {                                     
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
 2003a54:	c8 04 40 01 	ld  [ %l1 + %g1 ], %g4                         
 2003a58:	c6 00 ff d4 	ld  [ %g3 + -44 ], %g3                         
 2003a5c:	86 21 00 03 	sub  %g4, %g3, %g3                             
 2003a60:	80 a0 c0 1c 	cmp  %g3, %i4                                  
 2003a64:	0a 80 00 76 	bcs  2003c3c <rtems_bdpart_write+0x354>        <== NEVER TAKEN
 2003a68:	82 00 60 30 	add  %g1, 0x30, %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) {                                     
 2003a6c:	84 00 a0 01 	inc  %g2                                       
 2003a70:	80 a0 80 1b 	cmp  %g2, %i3                                  
 2003a74:	0a bf ff f8 	bcs  2003a54 <rtems_bdpart_write+0x16c>        
 2003a78:	86 04 40 01 	add  %l1, %g1, %g3                             
 2003a7c:	b0 10 00 1a 	mov  %i2, %i0                                  
 2003a80:	a6 10 20 00 	clr  %l3                                       
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
    uint8_t type = 0;                                                 
 2003a84:	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)) {       
 2003a88:	90 06 20 08 	add  %i0, 8, %o0                               
 2003a8c:	7f ff fe 1a 	call  20032f4 <rtems_bdpart_to_mbr_partition_type>
 2003a90:	92 07 bf ef 	add  %fp, -17, %o1                             
 2003a94:	80 8a 20 ff 	btst  0xff, %o0                                
 2003a98:	22 80 00 6c 	be,a   2003c48 <rtems_bdpart_write+0x360>      <== NEVER TAKEN
 2003a9c:	b0 10 20 04 	mov  4, %i0                                    <== NOT EXECUTED
 2003aa0:	b0 06 20 30 	add  %i0, 0x30, %i0                            
      esc =  RTEMS_INVALID_ID;                                        
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check flags */                                                 
    if (p->flags > 0xffU) {                                           
 2003aa4:	c2 06 3f f8 	ld  [ %i0 + -8 ], %g1                          
 2003aa8:	80 a0 60 00 	cmp  %g1, 0                                    
 2003aac:	32 80 00 67 	bne,a   2003c48 <rtems_bdpart_write+0x360>     <== NEVER TAKEN
 2003ab0:	b0 10 20 04 	mov  4, %i0                                    <== NOT EXECUTED
 2003ab4:	c2 06 3f fc 	ld  [ %i0 + -4 ], %g1                          
 2003ab8:	80 a0 60 ff 	cmp  %g1, 0xff                                 
 2003abc:	18 80 00 07 	bgu  2003ad8 <rtems_bdpart_write+0x1f0>        <== NEVER TAKEN
 2003ac0:	a6 04 e0 01 	inc  %l3                                       
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check that we can convert the parition descriptions to the MBR format */
  for (i = 0; i < count; ++i) {                                       
 2003ac4:	80 a4 c0 1b 	cmp  %l3, %i3                                  
 2003ac8:	32 bf ff f0 	bne,a   2003a88 <rtems_bdpart_write+0x1a0>     
 2003acc:	c0 2f bf ef 	clrb  [ %fp + -17 ]                            
    /* Check ID */                                                    
    /* TODO */                                                        
  }                                                                   
                                                                      
  /* New MBR */                                                       
  sc = rtems_bdpart_new_record( dd, 0, &block);                       
 2003ad0:	10 80 00 04 	b  2003ae0 <rtems_bdpart_write+0x1f8>          
 2003ad4:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 2003ad8:	10 80 00 5c 	b  2003c48 <rtems_bdpart_write+0x360>          <== NOT EXECUTED
 2003adc:	b0 10 20 04 	mov  4, %i0                                    <== NOT EXECUTED
 2003ae0:	92 10 20 00 	clr  %o1                                       
 2003ae4:	7f ff ff 48 	call  2003804 <rtems_bdpart_new_record>        
 2003ae8:	94 07 bf f0 	add  %fp, -16, %o2                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003aec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2003af0:	12 80 00 57 	bne  2003c4c <rtems_bdpart_write+0x364>        <== NEVER TAKEN
 2003af4:	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                   
 2003af8:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
 2003afc:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    format->mbr.disk_id,                                              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
 2003b00:	c8 00 60 1c 	ld  [ %g1 + 0x1c ], %g4                        
 2003b04:	82 10 20 00 	clr  %g1                                       
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
 2003b08:	86 01 00 01 	add  %g4, %g1, %g3                             
    data [i] = (uint8_t) value;                                       
 2003b0c:	c4 28 e1 b8 	stb  %g2, [ %g3 + 0x1b8 ]                      
                                                                      
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{                                                                     
  size_t i = 0;                                                       
                                                                      
  for (i = 0; i < 4; ++i) {                                           
 2003b10:	82 00 60 01 	inc  %g1                                       
 2003b14:	80 a0 60 04 	cmp  %g1, 4                                    
 2003b18:	12 bf ff fc 	bne  2003b08 <rtems_bdpart_write+0x220>        
 2003b1c:	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;             
 2003b20:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
  for (i = 0; i < ppc; ++i) {                                         
 2003b24:	b2 10 20 00 	clr  %i1                                       
    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;             
 2003b28:	e6 00 60 1c 	ld  [ %g1 + 0x1c ], %l3                        
 2003b2c:	a6 04 e1 be 	add  %l3, 0x1be, %l3                           
  for (i = 0; i < ppc; ++i) {                                         
 2003b30:	10 80 00 0b 	b  2003b5c <rtems_bdpart_write+0x274>          
 2003b34:	b0 10 00 13 	mov  %l3, %i0                                  
    const rtems_bdpart_partition *p = pt + i;                         
                                                                      
    /* Write partition entry */                                       
    rtems_bdpart_write_mbr_partition(                                 
 2003b38:	d4 04 20 04 	ld  [ %l0 + 4 ], %o2                           
 2003b3c:	d6 0c 20 08 	ldub  [ %l0 + 8 ], %o3                         
 2003b40:	d8 0c 20 2f 	ldub  [ %l0 + 0x2f ], %o4                      
 2003b44:	90 10 00 18 	mov  %i0, %o0                                  
 2003b48:	94 22 80 09 	sub  %o2, %o1, %o2                             
 2003b4c:	7f ff ff 56 	call  20038a4 <rtems_bdpart_write_mbr_partition>
 2003b50:	b0 06 20 10 	add  %i0, 0x10, %i0                            
    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) {                                         
 2003b54:	b2 06 60 01 	inc  %i1                                       
 2003b58:	a0 04 20 30 	add  %l0, 0x30, %l0                            
 2003b5c:	80 a6 40 1d 	cmp  %i1, %i5                                  
 2003b60:	32 bf ff f6 	bne,a   2003b38 <rtems_bdpart_write+0x250>     
 2003b64:	d2 04 00 00 	ld  [ %l0 ], %o1                               
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
 2003b68:	91 2f 60 04 	sll  %i5, 4, %o0                               
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
 2003b6c:	b0 10 20 00 	clr  %i0                                       
                                                                      
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                        
  }                                                                   
                                                                      
  /* Write extended partition with logical partitions if necessary */ 
  if (ppc != count) {                                                 
 2003b70:	80 a7 40 1b 	cmp  %i5, %i3                                  
 2003b74:	02 80 00 35 	be  2003c48 <rtems_bdpart_write+0x360>         <== NEVER TAKEN
 2003b78:	90 04 c0 08 	add  %l3, %o0, %o0                             
    rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ 
                                                                      
    /* Begin of extended partition */                                 
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;       
 2003b7c:	e0 06 80 12 	ld  [ %i2 + %l2 ], %l0                         
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
 2003b80:	d4 07 bf f4 	ld  [ %fp + -12 ], %o2                         
  /* 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;       
 2003b84:	a0 24 00 1c 	sub  %l0, %i4, %l0                             
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
 2003b88:	96 10 20 05 	mov  5, %o3                                    
 2003b8c:	92 10 00 10 	mov  %l0, %o1                                  
 2003b90:	94 22 80 10 	sub  %o2, %l0, %o2                             
 2003b94:	98 10 20 00 	clr  %o4                                       
 2003b98:	7f ff ff 43 	call  20038a4 <rtems_bdpart_write_mbr_partition>
 2003b9c:	b4 10 00 11 	mov  %l1, %i2                                  
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
 2003ba0:	10 80 00 22 	b  2003c28 <rtems_bdpart_write+0x340>          
 2003ba4:	b2 10 00 1d 	mov  %i5, %i1                                  
      const rtems_bdpart_partition *p = pt + i;                       
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
 2003ba8:	28 80 00 0e 	bleu,a   2003be0 <rtems_bdpart_write+0x2f8>    
 2003bac:	d2 06 80 00 	ld  [ %i2 ], %o1                               
        rtems_blkdev_bnum begin = p->begin - record_space;            
                                                                      
        rtems_bdpart_write_mbr_partition(                             
          block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,            
 2003bb0:	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;            
 2003bb4:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
        rtems_bdpart_write_mbr_partition(                             
 2003bb8:	d0 00 a0 1c 	ld  [ %g2 + 0x1c ], %o0                        
 2003bbc:	d4 07 bf f4 	ld  [ %fp + -12 ], %o2                         
    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;            
 2003bc0:	82 20 40 1c 	sub  %g1, %i4, %g1                             
                                                                      
        rtems_bdpart_write_mbr_partition(                             
 2003bc4:	90 02 21 ce 	add  %o0, 0x1ce, %o0                           
 2003bc8:	92 20 40 10 	sub  %g1, %l0, %o1                             
 2003bcc:	94 22 80 01 	sub  %o2, %g1, %o2                             
 2003bd0:	96 10 20 05 	mov  5, %o3                                    
 2003bd4:	7f ff ff 34 	call  20038a4 <rtems_bdpart_write_mbr_partition>
 2003bd8:	98 10 20 00 	clr  %o4                                       
          0                                                           
        );                                                            
      }                                                               
                                                                      
      /* New EBR */                                                   
      ebr = p->begin - record_space;                                  
 2003bdc:	d2 06 80 00 	ld  [ %i2 ], %o1                               
      sc = rtems_bdpart_new_record( dd, ebr, &block);                 
 2003be0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 2003be4:	92 22 40 1c 	sub  %o1, %i4, %o1                             
 2003be8:	7f ff ff 07 	call  2003804 <rtems_bdpart_new_record>        
 2003bec:	94 07 bf f0 	add  %fp, -16, %o2                             
      if (sc != RTEMS_SUCCESSFUL) {                                   
 2003bf0:	80 a2 20 00 	cmp  %o0, 0                                    
 2003bf4:	12 80 00 14 	bne  2003c44 <rtems_bdpart_write+0x35c>        <== NEVER TAKEN
 2003bf8:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
 2003bfc:	d4 06 a0 04 	ld  [ %i2 + 4 ], %o2                           
 2003c00:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 2003c04:	d6 0e a0 08 	ldub  [ %i2 + 8 ], %o3                         
 2003c08:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 2003c0c:	d8 0e a0 2f 	ldub  [ %i2 + 0x2f ], %o4                      
 2003c10:	90 02 21 be 	add  %o0, 0x1be, %o0                           
 2003c14:	92 10 00 1c 	mov  %i4, %o1                                  
 2003c18:	94 22 80 01 	sub  %o2, %g1, %o2                             
 2003c1c:	7f ff ff 22 	call  20038a4 <rtems_bdpart_write_mbr_partition>
 2003c20:	b2 06 60 01 	inc  %i1                                       
 2003c24:	b4 06 a0 30 	add  %i2, 0x30, %i2                            
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
 2003c28:	80 a6 40 1b 	cmp  %i1, %i3                                  
 2003c2c:	0a bf ff df 	bcs  2003ba8 <rtems_bdpart_write+0x2c0>        
 2003c30:	80 a6 40 1d 	cmp  %i1, %i5                                  
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
 2003c34:	10 80 00 05 	b  2003c48 <rtems_bdpart_write+0x360>          
 2003c38:	b0 10 20 00 	clr  %i0                                       
   * compatibility resides between the partitions.  So there have to be gaps of
   * the appropriate size between the partitions.                     
   */                                                                 
  for (i = ppc; i < count; ++i) {                                     
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
      esc = RTEMS_INVALID_NUMBER;                                     
 2003c3c:	10 80 00 03 	b  2003c48 <rtems_bdpart_write+0x360>          <== NOT EXECUTED
 2003c40:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
      }                                                               
                                                                      
      /* New EBR */                                                   
      ebr = p->begin - record_space;                                  
      sc = rtems_bdpart_new_record( dd, ebr, &block);                 
      if (sc != RTEMS_SUCCESSFUL) {                                   
 2003c44:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  if (fd >= 0) {                                                      
 2003c48:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
 2003c4c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003c50:	26 80 00 05 	bl,a   2003c64 <rtems_bdpart_write+0x37c>      <== NEVER TAKEN
 2003c54:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0                         <== NOT EXECUTED
    close( fd);                                                       
 2003c58:	40 00 06 4f 	call  2005594 <close>                          
 2003c5c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if (block != NULL) {                                                
 2003c60:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0                         
 2003c64:	80 a2 20 00 	cmp  %o0, 0                                    
 2003c68:	02 80 00 06 	be  2003c80 <rtems_bdpart_write+0x398>         <== NEVER TAKEN
 2003c6c:	01 00 00 00 	nop                                            
    rtems_bdbuf_sync( block);                                         
 2003c70:	40 00 31 01 	call  2010074 <rtems_bdbuf_sync>               
 2003c74:	01 00 00 00 	nop                                            
 2003c78:	81 c7 e0 08 	ret                                            
 2003c7c:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
 2003c80:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003c84:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003988 <rtems_blkdev_create_partition>: const char *partition, const char *parent_block_device, rtems_blkdev_bnum media_block_begin, rtems_blkdev_bnum media_block_count ) {
 2003988:	9d e3 bf 50 	save  %sp, -176, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int fd = open(parent_block_device, O_RDWR);                         
 200398c:	92 10 20 02 	mov  2, %o1                                    
 2003990:	90 10 00 19 	mov  %i1, %o0                                  
 2003994:	40 00 09 da 	call  20060fc <open>                           
 2003998:	ba 10 20 04 	mov  4, %i5                                    
                                                                      
  if (fd >= 0) {                                                      
 200399c:	80 a2 20 00 	cmp  %o0, 0                                    
 20039a0:	06 80 00 33 	bl  2003a6c <rtems_blkdev_create_partition+0xe4>
 20039a4:	b2 10 00 08 	mov  %o0, %i1                                  
    int rv;                                                           
    struct stat st;                                                   
                                                                      
    rv = fstat(fd, &st);                                              
 20039a8:	40 00 06 43 	call  20052b4 <fstat>                          
 20039ac:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rv == 0 && S_ISBLK(st.st_mode)) {                             
 20039b0:	80 a2 20 00 	cmp  %o0, 0                                    
 20039b4:	12 80 00 2c 	bne  2003a64 <rtems_blkdev_create_partition+0xdc><== NEVER TAKEN
 20039b8:	ba 10 20 15 	mov  0x15, %i5                                 
 20039bc:	e0 07 bf c4 	ld  [ %fp + -60 ], %l0                         
 20039c0:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 20039c4:	a0 0c 00 01 	and  %l0, %g1, %l0                             
 20039c8:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
 20039cc:	80 a4 00 01 	cmp  %l0, %g1                                  
 20039d0:	12 80 00 25 	bne  2003a64 <rtems_blkdev_create_partition+0xdc>
 20039d4:	90 10 00 19 	mov  %i1, %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);                   
 20039d8:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
 20039dc:	94 07 bf b4 	add  %fp, -76, %o2                             
 20039e0:	92 12 62 09 	or  %o1, 0x209, %o1                            
 20039e4:	40 00 06 87 	call  2005400 <ioctl>                          
 20039e8:	ba 10 20 18 	mov  0x18, %i5                                 
      rtems_disk_device *phys_dd;                                     
                                                                      
      rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);               
      if (rv == 0) {                                                  
 20039ec:	80 a2 20 00 	cmp  %o0, 0                                    
 20039f0:	12 80 00 1d 	bne  2003a64 <rtems_blkdev_create_partition+0xdc>
 20039f4:	01 00 00 00 	nop                                            
        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));        
 20039f8:	40 00 07 96 	call  2005850 <malloc>                         
 20039fc:	90 10 20 80 	mov  0x80, %o0	! 80 <PROM_START+0x80>          
                                                                      
        if (ctx != NULL) {                                            
 2003a00:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2003a04:	02 80 00 17 	be  2003a60 <rtems_blkdev_create_partition+0xd8>
 2003a08:	d2 07 bf b4 	ld  [ %fp + -76 ], %o1                         
          sc = rtems_disk_init_log(                                   
 2003a0c:	94 10 00 1a 	mov  %i2, %o2                                  
 2003a10:	40 00 00 90 	call  2003c50 <rtems_disk_init_log>            
 2003a14:	96 10 00 1b 	mov  %i3, %o3                                  
            phys_dd,                                                  
            media_block_begin,                                        
            media_block_count                                         
          );                                                          
                                                                      
          if (sc == RTEMS_SUCCESSFUL) {                               
 2003a18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2003a1c:	12 80 00 0e 	bne  2003a54 <rtems_blkdev_create_partition+0xcc>
 2003a20:	90 10 00 18 	mov  %i0, %o0                                  
            ctx->fd = fd;                                             
 2003a24:	f2 27 20 78 	st  %i1, [ %i4 + 0x78 ]                        
                                                                      
            rv = IMFS_make_generic_node(                              
 2003a28:	92 14 21 ff 	or  %l0, 0x1ff, %o1                            
 2003a2c:	15 00 80 7d 	sethi  %hi(0x201f400), %o2                     
 2003a30:	96 10 00 1c 	mov  %i4, %o3                                  
 2003a34:	40 00 03 90 	call  2004874 <IMFS_make_generic_node>         
 2003a38:	94 12 a3 30 	or  %o2, 0x330, %o2                            
              S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,                  
              &rtems_blkdev_imfs_control,                             
              ctx                                                     
            );                                                        
                                                                      
            if (rv != 0) {                                            
 2003a3c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003a40:	02 80 00 0b 	be  2003a6c <rtems_blkdev_create_partition+0xe4>
 2003a44:	90 10 00 1c 	mov  %i4, %o0                                  
              free(ctx);                                              
 2003a48:	40 00 05 f1 	call  200520c <free>                           
 2003a4c:	ba 10 20 0d 	mov  0xd, %i5                                  
 2003a50:	30 80 00 05 	b,a   2003a64 <rtems_blkdev_create_partition+0xdc>
              sc = RTEMS_UNSATISFIED;                                 
            }                                                         
          } else {                                                    
            free(ctx);                                                
 2003a54:	40 00 05 ee 	call  200520c <free>                           
 2003a58:	90 10 00 1c 	mov  %i4, %o0                                  
 2003a5c:	30 80 00 02 	b,a   2003a64 <rtems_blkdev_create_partition+0xdc>
 2003a60:	ba 10 20 1a 	mov  0x1a, %i5                                 
    } else {                                                          
      sc = RTEMS_INVALID_NODE;                                        
    }                                                                 
                                                                      
    if (sc != RTEMS_SUCCESSFUL) {                                     
      close(fd);                                                      
 2003a64:	40 00 05 2d 	call  2004f18 <close>                          
 2003a68:	90 10 00 19 	mov  %i1, %o0                                  
  } else {                                                            
    sc = RTEMS_INVALID_ID;                                            
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 2003a6c:	81 c7 e0 08 	ret                                            
 2003a70:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

0200f388 <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) {
 200f388:	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;                               
 200f38c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
 200f390:	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;                               
 200f394:	d0 00 60 30 	ld  [ %g1 + 0x30 ], %o0                        
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
 200f398:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
 200f39c:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <RAM_END+0xbdd84201>
 200f3a0:	80 a2 40 01 	cmp  %o1, %g1                                  
 200f3a4:	02 80 00 07 	be  200f3c0 <rtems_blkdev_generic_ioctl+0x38>  <== NEVER TAKEN
 200f3a8:	82 10 3f ff 	mov  -1, %g1                                   
    {                                                                 
        args->ioctl_return = dd->ioctl(dd,                            
 200f3ac:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 200f3b0:	9f c0 40 00 	call  %g1                                      
 200f3b4:	d4 06 a0 08 	ld  [ %i2 + 8 ], %o2                           
 200f3b8:	10 80 00 03 	b  200f3c4 <rtems_blkdev_generic_ioctl+0x3c>   
 200f3bc:	d0 26 a0 0c 	st  %o0, [ %i2 + 0xc ]                         
    {                                                                 
        /*                                                            
         * It is not allowed to directly access the driver circumventing the
         * cache.                                                     
         */                                                           
        args->ioctl_return = -1;                                      
 200f3c0:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]                         <== NOT EXECUTED
    }                                                                 
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
 200f3c4:	81 c7 e0 08 	ret                                            
 200f3c8:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

0200f168 <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) {
 200f168:	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;                               
 200f16c:	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);
 200f170:	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;                               
 200f174:	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);
 200f178:	90 10 00 1c 	mov  %i4, %o0                                  
{                                                                     
    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;                             
 200f17c:	e0 04 a0 24 	ld  [ %l2 + 0x24 ], %l0                        
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
 200f180:	94 10 20 00 	clr  %o2                                       
 200f184:	96 10 00 10 	mov  %l0, %o3                                  
 200f188:	40 00 37 09 	call  201cdac <__divdi3>                       
 200f18c:	92 10 00 1d 	mov  %i5, %o1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
 200f190:	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);
 200f194:	a6 10 00 09 	mov  %o1, %l3                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
 200f198:	94 10 20 00 	clr  %o2                                       
 200f19c:	92 10 00 1d 	mov  %i5, %o1                                  
 200f1a0:	96 10 00 10 	mov  %l0, %o3                                  
 200f1a4:	40 00 37 ed 	call  201d158 <__moddi3>                       
 200f1a8:	f2 06 a0 10 	ld  [ %i2 + 0x10 ], %i1                        
    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;                                     
 200f1ac:	f6 06 a0 14 	ld  [ %i2 + 0x14 ], %i3                        
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
 200f1b0:	a2 10 00 09 	mov  %o1, %l1                                  
                                                                      
    args->bytes_moved = 0;                                            
 200f1b4:	c0 26 a0 1c 	clr  [ %i2 + 0x1c ]                            
                                                                      
    while (count > 0)                                                 
 200f1b8:	10 80 00 1c 	b  200f228 <rtems_blkdev_generic_read+0xc0>    
 200f1bc:	b8 10 20 00 	clr  %i4                                       
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dd, block, &diskbuf);                   
 200f1c0:	90 10 00 12 	mov  %l2, %o0                                  
 200f1c4:	7f ff fd a6 	call  200e85c <rtems_bdbuf_read>               
 200f1c8:	94 07 bf fc 	add  %fp, -4, %o2                              
        if (rc != RTEMS_SUCCESSFUL)                                   
 200f1cc:	80 a2 20 00 	cmp  %o0, 0                                    
 200f1d0:	12 80 00 1a 	bne  200f238 <rtems_blkdev_generic_read+0xd0>  <== NEVER TAKEN
 200f1d4:	ba 24 00 11 	sub  %l0, %l1, %i5                             
 200f1d8:	80 a7 40 1b 	cmp  %i5, %i3                                  
 200f1dc:	38 80 00 02 	bgu,a   200f1e4 <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
 200f1e0:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
            break;                                                    
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
 200f1e4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200f1e8:	94 10 00 1d 	mov  %i5, %o2                                  
 200f1ec:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
 200f1f0:	90 10 00 19 	mov  %i1, %o0                                  
 200f1f4:	40 00 14 50 	call  2014334 <memcpy>                         
 200f1f8:	92 02 40 11 	add  %o1, %l1, %o1                             
        rc = rtems_bdbuf_release(diskbuf);                            
 200f1fc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 200f200:	7f ff fe 13 	call  200ea4c <rtems_bdbuf_release>            
 200f204:	b8 07 20 01 	inc  %i4                                       
        args->bytes_moved += copy;                                    
 200f208:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
        if (rc != RTEMS_SUCCESSFUL)                                   
 200f20c:	80 a2 20 00 	cmp  %o0, 0                                    
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
        rc = rtems_bdbuf_release(diskbuf);                            
        args->bytes_moved += copy;                                    
 200f210:	82 00 40 1d 	add  %g1, %i5, %g1                             
        if (rc != RTEMS_SUCCESSFUL)                                   
 200f214:	12 80 00 09 	bne  200f238 <rtems_blkdev_generic_read+0xd0>  <== NEVER TAKEN
 200f218:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]                        
            break;                                                    
        count -= copy;                                                
 200f21c:	b6 26 c0 1d 	sub  %i3, %i5, %i3                             
        buf += copy;                                                  
 200f220:	b2 06 40 1d 	add  %i1, %i5, %i1                             
        blkofs = 0;                                                   
 200f224:	a2 10 20 00 	clr  %l1                                       
    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)                                                 
 200f228:	80 a6 e0 00 	cmp  %i3, 0                                    
 200f22c:	12 bf ff e5 	bne  200f1c0 <rtems_blkdev_generic_read+0x58>  
 200f230:	92 07 00 13 	add  %i4, %l3, %o1                             
 200f234:	90 10 20 00 	clr  %o0                                       
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
 200f238:	81 c7 e0 08 	ret                                            
 200f23c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0200f240 <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) {
 200f240:	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;                               
 200f244:	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);
 200f248:	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;                               
 200f24c:	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);
 200f250:	90 10 00 1c 	mov  %i4, %o0                                  
{                                                                     
    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;                             
 200f254:	f2 04 60 24 	ld  [ %l1 + 0x24 ], %i1                        
    char *buf = args->buffer;                                         
    uint32_t count = args->count;                                     
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
 200f258:	94 10 20 00 	clr  %o2                                       
 200f25c:	96 10 00 19 	mov  %i1, %o3                                  
 200f260:	40 00 36 d3 	call  201cdac <__divdi3>                       
 200f264:	92 10 00 1d 	mov  %i5, %o1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
 200f268:	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);
 200f26c:	a4 10 00 09 	mov  %o1, %l2                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
 200f270:	94 10 20 00 	clr  %o2                                       
 200f274:	92 10 00 1d 	mov  %i5, %o1                                  
 200f278:	96 10 00 19 	mov  %i1, %o3                                  
 200f27c:	40 00 37 b7 	call  201d158 <__moddi3>                       
 200f280:	e0 06 a0 10 	ld  [ %i2 + 0x10 ], %l0                        
    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;                                     
 200f284:	f6 06 a0 14 	ld  [ %i2 + 0x14 ], %i3                        
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
 200f288:	b8 10 00 09 	mov  %o1, %i4                                  
                                                                      
    args->bytes_moved = 0;                                            
 200f28c:	c0 26 a0 1c 	clr  [ %i2 + 0x1c ]                            
                                                                      
    while (count > 0)                                                 
 200f290:	10 80 00 26 	b  200f328 <rtems_blkdev_generic_write+0xe8>   
 200f294:	b0 10 20 00 	clr  %i0                                       
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
 200f298:	90 10 00 11 	mov  %l1, %o0                                  
    while (count > 0)                                                 
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
 200f29c:	80 a6 c0 19 	cmp  %i3, %i1                                  
 200f2a0:	0a 80 00 09 	bcs  200f2c4 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
 200f2a4:	94 07 bf fc 	add  %fp, -4, %o2                              
 200f2a8:	80 a7 20 00 	cmp  %i4, 0                                    
 200f2ac:	12 80 00 06 	bne  200f2c4 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
 200f2b0:	01 00 00 00 	nop                                            
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
 200f2b4:	7f ff fd 39 	call  200e798 <rtems_bdbuf_get>                
 200f2b8:	01 00 00 00 	nop                                            
        else                                                          
            rc = rtems_bdbuf_read(dd, block, &diskbuf);               
        if (rc != RTEMS_SUCCESSFUL)                                   
 200f2bc:	10 80 00 05 	b  200f2d0 <rtems_blkdev_generic_write+0x90>   
 200f2c0:	80 a2 20 00 	cmp  %o0, 0                                    
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
        else                                                          
            rc = rtems_bdbuf_read(dd, block, &diskbuf);               
 200f2c4:	7f ff fd 66 	call  200e85c <rtems_bdbuf_read>               <== NOT EXECUTED
 200f2c8:	01 00 00 00 	nop                                            <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
 200f2cc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 200f2d0:	12 80 00 1a 	bne  200f338 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
 200f2d4:	ba 26 40 1c 	sub  %i1, %i4, %i5                             
 200f2d8:	80 a7 40 1b 	cmp  %i5, %i3                                  
 200f2dc:	38 80 00 02 	bgu,a   200f2e4 <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
 200f2e0:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
            break;                                                    
                                                                      
        copy = block_size - blkofs;                                   
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
 200f2e4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200f2e8:	92 10 00 10 	mov  %l0, %o1                                  
 200f2ec:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 200f2f0:	94 10 00 1d 	mov  %i5, %o2                                  
 200f2f4:	40 00 14 10 	call  2014334 <memcpy>                         
 200f2f8:	90 02 00 1c 	add  %o0, %i4, %o0                             
        args->bytes_moved += copy;                                    
 200f2fc:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
 200f300:	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;                                    
 200f304:	82 00 40 1d 	add  %g1, %i5, %g1                             
 200f308:	b0 06 20 01 	inc  %i0                                       
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
 200f30c:	7f ff fe 05 	call  200eb20 <rtems_bdbuf_release_modified>   
 200f310:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]                        
        if (rc != RTEMS_SUCCESSFUL)                                   
 200f314:	80 a2 20 00 	cmp  %o0, 0                                    
 200f318:	12 80 00 08 	bne  200f338 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
 200f31c:	b6 26 c0 1d 	sub  %i3, %i5, %i3                             
            break;                                                    
                                                                      
        count -= copy;                                                
        buf += copy;                                                  
 200f320:	a0 04 00 1d 	add  %l0, %i5, %l0                             
        blkofs = 0;                                                   
 200f324:	b8 10 20 00 	clr  %i4                                       
    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)                                                 
 200f328:	80 a6 e0 00 	cmp  %i3, 0                                    
 200f32c:	12 bf ff db 	bne  200f298 <rtems_blkdev_generic_write+0x58> 
 200f330:	92 06 00 12 	add  %i0, %l2, %o1                             
 200f334:	90 10 20 00 	clr  %o0                                       
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
 200f338:	81 c7 e0 08 	ret                                            
 200f33c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

02003874 <rtems_blkdev_imfs_fsync_or_fdatasync>: } static int rtems_blkdev_imfs_fsync_or_fdatasync( rtems_libio_t *iop ) {
 2003874:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
static inline void *IMFS_generic_get_context_by_node(                 
  const IMFS_jnode_t *node                                            
)                                                                     
{                                                                     
  return node->info.generic.context;                                  
 2003878:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
  int rv = 0;                                                         
 200387c:	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);                     
 2003880:	40 00 2f e0 	call  200f800 <rtems_bdbuf_syncdev>            
 2003884:	d0 00 60 50 	ld  [ %g1 + 0x50 ], %o0                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003888:	80 a2 20 00 	cmp  %o0, 0                                    
 200388c:	02 80 00 06 	be  20038a4 <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== ALWAYS TAKEN
 2003890:	01 00 00 00 	nop                                            
    errno = EIO;                                                      
 2003894:	40 00 41 d7 	call  2013ff0 <__errno>                        <== NOT EXECUTED
 2003898:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 200389c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 20038a0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 20038a4:	81 c7 e0 08 	ret                                            
 20038a8:	81 e8 00 00 	restore                                        
                                                                      

020038ac <rtems_blkdev_imfs_ioctl>: static int rtems_blkdev_imfs_ioctl( rtems_libio_t *iop, uint32_t request, void *buffer ) {
 20038ac:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  if (request != RTEMS_BLKIO_REQUEST) {                               
 20038b0:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
 20038b4:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <RAM_END+0xbdd84201>
 20038b8:	80 a6 40 01 	cmp  %i1, %g1                                  
 20038bc:	02 80 00 09 	be  20038e0 <rtems_blkdev_imfs_ioctl+0x34>     <== NEVER TAKEN
 20038c0:	92 10 00 19 	mov  %i1, %o1                                  
 20038c4:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
 20038c8:	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);                           
 20038cc:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 20038d0:	9f c0 40 00 	call  %g1                                      
 20038d4:	94 10 00 1a 	mov  %i2, %o2                                  
 20038d8:	81 c7 e0 08 	ret                                            
 20038dc:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  } else {                                                            
    /*                                                                
     * It is not allowed to directly access the driver circumventing the cache.
     */                                                               
    errno = EINVAL;                                                   
 20038e0:	40 00 41 c4 	call  2013ff0 <__errno>                        <== NOT EXECUTED
 20038e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20038e8:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
 20038ec:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 20038f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20038f4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020036f8 <rtems_blkdev_imfs_read>: static ssize_t rtems_blkdev_imfs_read( rtems_libio_t *iop, void *buffer, size_t count ) {
 20036f8:	9d e3 bf 98 	save  %sp, -104, %sp                           
 20036fc:	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;                                         
 2003700:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
 2003704:	e4 00 60 50 	ld  [ %g1 + 0x50 ], %l2                        
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
 2003708:	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);       
 200370c:	f6 04 a0 24 	ld  [ %l2 + 0x24 ], %i3                        
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
 2003710:	90 10 00 1c 	mov  %i4, %o0                                  
 2003714:	a3 3e e0 1f 	sra  %i3, 0x1f, %l1                            
 2003718:	96 10 00 1b 	mov  %i3, %o3                                  
 200371c:	40 00 67 85 	call  201d530 <__divdi3>                       
 2003720:	94 10 00 11 	mov  %l1, %o2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
 2003724:	94 10 00 11 	mov  %l1, %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);
 2003728:	a0 10 00 09 	mov  %o1, %l0                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
 200372c:	90 10 00 1c 	mov  %i4, %o0                                  
 2003730:	92 10 00 1d 	mov  %i5, %o1                                  
 2003734:	96 10 00 1b 	mov  %i3, %o3                                  
 2003738:	40 00 68 69 	call  201d8dc <__moddi3>                       
 200373c:	ba 10 00 1a 	mov  %i2, %i5                                  
  char *dst = buffer;                                                 
                                                                      
  while (remaining > 0) {                                             
 2003740:	10 80 00 19 	b  20037a4 <rtems_blkdev_imfs_read+0xac>       
 2003744:	a2 10 00 09 	mov  %o1, %l1                                  
    rtems_bdbuf_buffer *bd;                                           
    rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);          
 2003748:	92 10 00 10 	mov  %l0, %o1                                  
 200374c:	40 00 2f 12 	call  200f394 <rtems_bdbuf_read>               
 2003750:	94 07 bf fc 	add  %fp, -4, %o2                              
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
 2003754:	80 a2 20 00 	cmp  %o0, 0                                    
 2003758:	12 80 00 1f 	bne  20037d4 <rtems_blkdev_imfs_read+0xdc>     <== NEVER TAKEN
 200375c:	b8 26 c0 11 	sub  %i3, %l1, %i4                             
 2003760:	80 a7 00 1d 	cmp  %i4, %i5                                  
 2003764:	34 80 00 02 	bg,a   200376c <rtems_blkdev_imfs_read+0x74>   
 2003768:	b8 10 00 1d 	mov  %i5, %i4                                  
                                                                      
      if (copy > remaining) {                                         
        copy = remaining;                                             
      }                                                               
                                                                      
      memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy); 
 200376c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2003770:	94 10 00 1c 	mov  %i4, %o2                                  
 2003774:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
 2003778:	90 10 00 19 	mov  %i1, %o0                                  
 200377c:	40 00 44 98 	call  20149dc <memcpy>                         
 2003780:	92 02 40 11 	add  %o1, %l1, %o1                             
                                                                      
      sc = rtems_bdbuf_release(bd);                                   
 2003784:	40 00 2f 80 	call  200f584 <rtems_bdbuf_release>            
 2003788:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      if (sc == RTEMS_SUCCESSFUL) {                                   
 200378c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003790:	12 80 00 11 	bne  20037d4 <rtems_blkdev_imfs_read+0xdc>     <== NEVER TAKEN
 2003794:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
        block_offset = 0;                                             
        remaining -= copy;                                            
        dst += copy;                                                  
 2003798:	b2 06 40 1c 	add  %i1, %i4, %i1                             
        ++block;                                                      
 200379c:	a0 04 20 01 	inc  %l0                                       
                                                                      
      memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy); 
                                                                      
      sc = rtems_bdbuf_release(bd);                                   
      if (sc == RTEMS_SUCCESSFUL) {                                   
        block_offset = 0;                                             
 20037a0:	a2 10 20 00 	clr  %l1                                       
  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) {                                             
 20037a4:	80 a7 60 00 	cmp  %i5, 0                                    
 20037a8:	14 bf ff e8 	bg  2003748 <rtems_blkdev_imfs_read+0x50>      
 20037ac:	90 10 00 12 	mov  %l2, %o0                                  
    } else {                                                          
      remaining = -1;                                                 
    }                                                                 
  }                                                                   
                                                                      
  if (remaining >= 0) {                                               
 20037b0:	80 a7 60 00 	cmp  %i5, 0                                    
 20037b4:	12 80 00 08 	bne  20037d4 <rtems_blkdev_imfs_read+0xdc>     <== NEVER TAKEN
 20037b8:	01 00 00 00 	nop                                            
    iop->offset += count;                                             
 20037bc:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
 20037c0:	86 80 c0 1a 	addcc  %g3, %i2, %g3                           
 20037c4:	84 40 a0 00 	addx  %g2, 0, %g2                              
 20037c8:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    rv = (ssize_t) count;                                             
 20037cc:	81 c7 e0 08 	ret                                            
 20037d0:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
  } else {                                                            
    errno = EIO;                                                      
 20037d4:	40 00 42 07 	call  2013ff0 <__errno>                        <== NOT EXECUTED
 20037d8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20037dc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 20037e0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 20037e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20037e8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020035cc <rtems_blkdev_imfs_write>: static ssize_t rtems_blkdev_imfs_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
 20035cc:	9d e3 bf 98 	save  %sp, -104, %sp                           
 20035d0:	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;                                         
 20035d4:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
 20035d8:	e4 00 60 50 	ld  [ %g1 + 0x50 ], %l2                        
  ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);       
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
 20035dc:	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);       
 20035e0:	f6 04 a0 24 	ld  [ %l2 + 0x24 ], %i3                        
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
 20035e4:	90 10 00 1c 	mov  %i4, %o0                                  
 20035e8:	a3 3e e0 1f 	sra  %i3, 0x1f, %l1                            
 20035ec:	96 10 00 1b 	mov  %i3, %o3                                  
 20035f0:	40 00 67 d0 	call  201d530 <__divdi3>                       
 20035f4:	94 10 00 11 	mov  %l1, %o2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
 20035f8:	94 10 00 11 	mov  %l1, %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);
 20035fc:	a0 10 00 09 	mov  %o1, %l0                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
 2003600:	90 10 00 1c 	mov  %i4, %o0                                  
 2003604:	92 10 00 1d 	mov  %i5, %o1                                  
 2003608:	96 10 00 1b 	mov  %i3, %o3                                  
 200360c:	40 00 68 b4 	call  201d8dc <__moddi3>                       
 2003610:	ba 10 00 1a 	mov  %i2, %i5                                  
  const char *src = buffer;                                           
                                                                      
  while (remaining > 0) {                                             
 2003614:	10 80 00 27 	b  20036b0 <rtems_blkdev_imfs_write+0xe4>      
 2003618:	a2 10 00 09 	mov  %o1, %l1                                  
    rtems_status_code sc;                                             
    rtems_bdbuf_buffer *bd;                                           
                                                                      
    if (block_offset == 0 && remaining >= block_size) {               
 200361c:	16 80 00 03 	bge  2003628 <rtems_blkdev_imfs_write+0x5c>    
 2003620:	82 10 20 01 	mov  1, %g1                                    
 2003624:	82 10 20 00 	clr  %g1                                       
       sc = rtems_bdbuf_get(dd, block, &bd);                          
 2003628:	90 10 00 12 	mov  %l2, %o0                                  
 200362c:	92 10 00 10 	mov  %l0, %o1                                  
                                                                      
  while (remaining > 0) {                                             
    rtems_status_code sc;                                             
    rtems_bdbuf_buffer *bd;                                           
                                                                      
    if (block_offset == 0 && remaining >= block_size) {               
 2003630:	80 88 60 ff 	btst  0xff, %g1                                
 2003634:	02 80 00 09 	be  2003658 <rtems_blkdev_imfs_write+0x8c>     
 2003638:	94 07 bf fc 	add  %fp, -4, %o2                              
 200363c:	80 a4 60 00 	cmp  %l1, 0                                    
 2003640:	12 80 00 06 	bne  2003658 <rtems_blkdev_imfs_write+0x8c>    
 2003644:	01 00 00 00 	nop                                            
       sc = rtems_bdbuf_get(dd, block, &bd);                          
 2003648:	40 00 2f 22 	call  200f2d0 <rtems_bdbuf_get>                
 200364c:	01 00 00 00 	nop                                            
    } else {                                                          
       sc = rtems_bdbuf_read(dd, block, &bd);                         
    }                                                                 
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
 2003650:	10 80 00 05 	b  2003664 <rtems_blkdev_imfs_write+0x98>      
 2003654:	80 a2 20 00 	cmp  %o0, 0                                    
    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);                         
 2003658:	40 00 2f 4f 	call  200f394 <rtems_bdbuf_read>               
 200365c:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
 2003660:	80 a2 20 00 	cmp  %o0, 0                                    
 2003664:	12 80 00 1f 	bne  20036e0 <rtems_blkdev_imfs_write+0x114>   <== NEVER TAKEN
 2003668:	b8 26 c0 11 	sub  %i3, %l1, %i4                             
 200366c:	80 a7 00 1d 	cmp  %i4, %i5                                  
 2003670:	34 80 00 02 	bg,a   2003678 <rtems_blkdev_imfs_write+0xac>  
 2003674:	b8 10 00 1d 	mov  %i5, %i4                                  
                                                                      
      if (copy > remaining) {                                         
        copy = remaining;                                             
      }                                                               
                                                                      
      memcpy((char *) bd->buffer + block_offset, src, (size_t) copy); 
 2003678:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200367c:	92 10 00 19 	mov  %i1, %o1                                  
 2003680:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 2003684:	94 10 00 1c 	mov  %i4, %o2                                  
 2003688:	40 00 44 d5 	call  20149dc <memcpy>                         
 200368c:	90 02 00 11 	add  %o0, %l1, %o0                             
                                                                      
      sc = rtems_bdbuf_release_modified(bd);                          
 2003690:	40 00 2f f2 	call  200f658 <rtems_bdbuf_release_modified>   
 2003694:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      if (sc == RTEMS_SUCCESSFUL) {                                   
 2003698:	80 a2 20 00 	cmp  %o0, 0                                    
 200369c:	12 80 00 11 	bne  20036e0 <rtems_blkdev_imfs_write+0x114>   <== NEVER TAKEN
 20036a0:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
        block_offset = 0;                                             
        remaining -= copy;                                            
        src += copy;                                                  
 20036a4:	b2 06 40 1c 	add  %i1, %i4, %i1                             
        ++block;                                                      
 20036a8:	a0 04 20 01 	inc  %l0                                       
                                                                      
      memcpy((char *) bd->buffer + block_offset, src, (size_t) copy); 
                                                                      
      sc = rtems_bdbuf_release_modified(bd);                          
      if (sc == RTEMS_SUCCESSFUL) {                                   
        block_offset = 0;                                             
 20036ac:	a2 10 20 00 	clr  %l1                                       
  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) {                                             
 20036b0:	80 a7 60 00 	cmp  %i5, 0                                    
 20036b4:	14 bf ff da 	bg  200361c <rtems_blkdev_imfs_write+0x50>     
 20036b8:	80 a7 40 1b 	cmp  %i5, %i3                                  
    } else {                                                          
      remaining = -1;                                                 
    }                                                                 
  }                                                                   
                                                                      
  if (remaining >= 0) {                                               
 20036bc:	80 a7 60 00 	cmp  %i5, 0                                    
 20036c0:	12 80 00 08 	bne  20036e0 <rtems_blkdev_imfs_write+0x114>   <== NEVER TAKEN
 20036c4:	01 00 00 00 	nop                                            
    iop->offset += count;                                             
 20036c8:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
 20036cc:	86 80 c0 1a 	addcc  %g3, %i2, %g3                           
 20036d0:	84 40 a0 00 	addx  %g2, 0, %g2                              
 20036d4:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    rv = (ssize_t) count;                                             
 20036d8:	81 c7 e0 08 	ret                                            
 20036dc:	91 e8 00 1a 	restore  %g0, %i2, %o0                         
  } else {                                                            
    errno = EIO;                                                      
 20036e0:	40 00 42 44 	call  2013ff0 <__errno>                        <== NOT EXECUTED
 20036e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20036e8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
 20036ec:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 20036f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20036f4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200f010 <rtems_blkdev_ioctl>: #include <rtems/blkdev.h> #include <rtems/bdbuf.h> int rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) {
 200f010:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
 200f014:	03 10 01 10 	sethi  %hi(0x40044000), %g1                    
 200f018:	84 10 62 03 	or  %g1, 0x203, %g2	! 40044203 <RAM_END+0x3dc44203>
 200f01c:	80 a6 40 02 	cmp  %i1, %g2                                  
 200f020:	02 80 00 2f 	be  200f0dc <rtems_blkdev_ioctl+0xcc>          
 200f024:	90 10 00 18 	mov  %i0, %o0                                  
 200f028:	80 a6 40 02 	cmp  %i1, %g2                                  
 200f02c:	18 80 00 16 	bgu  200f084 <rtems_blkdev_ioctl+0x74>         
 200f030:	84 10 62 09 	or  %g1, 0x209, %g2                            
 200f034:	05 08 00 10 	sethi  %hi(0x20004000), %g2                    
 200f038:	86 10 a2 0a 	or  %g2, 0x20a, %g3	! 2000420a <RAM_END+0x1dc0420a>
 200f03c:	80 a6 40 03 	cmp  %i1, %g3                                  
 200f040:	02 80 00 38 	be  200f120 <rtems_blkdev_ioctl+0x110>         
 200f044:	01 00 00 00 	nop                                            
 200f048:	38 80 00 07 	bgu,a   200f064 <rtems_blkdev_ioctl+0x54>      
 200f04c:	84 10 a2 0c 	or  %g2, 0x20c, %g2                            
 200f050:	84 10 a2 06 	or  %g2, 0x206, %g2                            
 200f054:	80 a6 40 02 	cmp  %i1, %g2                                  
 200f058:	12 80 00 3d 	bne  200f14c <rtems_blkdev_ioctl+0x13c>        
 200f05c:	01 00 00 00 	nop                                            
 200f060:	30 80 00 27 	b,a   200f0fc <rtems_blkdev_ioctl+0xec>        
 200f064:	80 a6 40 02 	cmp  %i1, %g2                                  
 200f068:	02 80 00 35 	be  200f13c <rtems_blkdev_ioctl+0x12c>         
 200f06c:	82 10 62 02 	or  %g1, 0x202, %g1                            
 200f070:	80 a6 40 01 	cmp  %i1, %g1                                  
 200f074:	12 80 00 36 	bne  200f14c <rtems_blkdev_ioctl+0x13c>        <== NEVER TAKEN
 200f078:	01 00 00 00 	nop                                            
    {                                                                 
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *(uint32_t *) argp = dd->media_block_size;                
 200f07c:	10 80 00 16 	b  200f0d4 <rtems_blkdev_ioctl+0xc4>           
 200f080:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
 200f084:	80 a6 40 02 	cmp  %i1, %g2                                  
 200f088:	22 80 00 2f 	be,a   200f144 <rtems_blkdev_ioctl+0x134>      
 200f08c:	f0 26 80 00 	st  %i0, [ %i2 ]                               
 200f090:	38 80 00 08 	bgu,a   200f0b0 <rtems_blkdev_ioctl+0xa0>      
 200f094:	82 10 62 0b 	or  %g1, 0x20b, %g1                            
 200f098:	82 10 62 05 	or  %g1, 0x205, %g1                            
 200f09c:	80 a6 40 01 	cmp  %i1, %g1                                  
 200f0a0:	12 80 00 2b 	bne  200f14c <rtems_blkdev_ioctl+0x13c>        <== NEVER TAKEN
 200f0a4:	01 00 00 00 	nop                                            
                rc = -1;                                              
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *(rtems_blkdev_bnum *) argp = dd->size;                   
 200f0a8:	10 80 00 13 	b  200f0f4 <rtems_blkdev_ioctl+0xe4>           
 200f0ac:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
 200f0b0:	80 a6 40 01 	cmp  %i1, %g1                                  
 200f0b4:	02 80 00 1e 	be  200f12c <rtems_blkdev_ioctl+0x11c>         
 200f0b8:	03 20 01 10 	sethi  %hi(0x80044000), %g1                    
 200f0bc:	82 10 62 04 	or  %g1, 0x204, %g1	! 80044204 <RAM_END+0x7dc44204>
 200f0c0:	80 a6 40 01 	cmp  %i1, %g1                                  
 200f0c4:	12 80 00 22 	bne  200f14c <rtems_blkdev_ioctl+0x13c>        <== NEVER TAKEN
 200f0c8:	01 00 00 00 	nop                                            
        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);
 200f0cc:	10 80 00 06 	b  200f0e4 <rtems_blkdev_ioctl+0xd4>           
 200f0d0:	d2 06 80 00 	ld  [ %i2 ], %o1                               
                rc = -1;                                              
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *(rtems_blkdev_bnum *) argp = dd->size;                   
 200f0d4:	10 80 00 1c 	b  200f144 <rtems_blkdev_ioctl+0x134>          
 200f0d8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *(uint32_t *) argp = dd->media_block_size;                
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETBLKSIZE:                                  
            *(uint32_t *) argp = dd->block_size;                      
 200f0dc:	10 80 00 06 	b  200f0f4 <rtems_blkdev_ioctl+0xe4>           
 200f0e0:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SETBLKSIZE:                                  
            sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);
 200f0e4:	7f ff ff 7c 	call  200eed4 <rtems_bdbuf_set_block_size>     
 200f0e8:	94 10 20 01 	mov  1, %o2                                    
            *(rtems_blkdev_bnum *) argp = dd->size;                   
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SYNCDEV:                                     
            sc = rtems_bdbuf_syncdev(dd);                             
            if (sc != RTEMS_SUCCESSFUL) {                             
 200f0ec:	10 80 00 07 	b  200f108 <rtems_blkdev_ioctl+0xf8>           
 200f0f0:	80 a2 20 00 	cmp  %o0, 0                                    
                rc = -1;                                              
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *(rtems_blkdev_bnum *) argp = dd->size;                   
 200f0f4:	10 80 00 14 	b  200f144 <rtems_blkdev_ioctl+0x134>          
 200f0f8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SYNCDEV:                                     
            sc = rtems_bdbuf_syncdev(dd);                             
 200f0fc:	7f ff fe f3 	call  200ecc8 <rtems_bdbuf_syncdev>            
 200f100:	01 00 00 00 	nop                                            
            if (sc != RTEMS_SUCCESSFUL) {                             
 200f104:	80 a2 20 00 	cmp  %o0, 0                                    
 200f108:	22 80 00 16 	be,a   200f160 <rtems_blkdev_ioctl+0x150>      <== ALWAYS TAKEN
 200f10c:	b0 10 20 00 	clr  %i0                                       
                errno = EIO;                                          
 200f110:	40 00 12 38 	call  20139f0 <__errno>                        <== NOT EXECUTED
 200f114:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200f118:	10 80 00 10 	b  200f158 <rtems_blkdev_ioctl+0x148>          <== NOT EXECUTED
 200f11c:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
        case RTEMS_BLKIO_GETDISKDEV:                                  
            *(rtems_disk_device **) argp = dd;                        
            break;                                                    
                                                                      
        case RTEMS_BLKIO_PURGEDEV:                                    
            rtems_bdbuf_purge_dev(dd);                                
 200f120:	7f ff ff 01 	call  200ed24 <rtems_bdbuf_purge_dev>          
 200f124:	b0 10 20 00 	clr  %i0                                       
 200f128:	30 80 00 0e 	b,a   200f160 <rtems_blkdev_ioctl+0x150>       
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETDEVSTATS:                                 
            rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
 200f12c:	7f ff ff a7 	call  200efc8 <rtems_bdbuf_get_device_stats>   
 200f130:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
int                                                                   
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)   
{                                                                     
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
 200f134:	81 c7 e0 08 	ret                                            
 200f138:	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);                       
 200f13c:	7f ff ff ac 	call  200efec <rtems_bdbuf_reset_device_stats> 
 200f140:	01 00 00 00 	nop                                            
            break;                                                    
 200f144:	81 c7 e0 08 	ret                                            
 200f148:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
        default:                                                      
            errno = EINVAL;                                           
 200f14c:	40 00 12 29 	call  20139f0 <__errno>                        
 200f150:	01 00 00 00 	nop                                            
 200f154:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 200f158:	c2 22 00 00 	st  %g1, [ %o0 ]                               
            rc = -1;                                                  
 200f15c:	b0 10 3f ff 	mov  -1, %i0                                   
            break;                                                    
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
 200f160:	81 c7 e0 08 	ret                                            
 200f164:	81 e8 00 00 	restore                                        
                                                                      

020222e4 <rtems_blkstats>: #include <fcntl.h> #include <unistd.h> #include <errno.h> void rtems_blkstats(FILE *output, const char *device, bool reset) {
 20222e4:	9d e3 bf 38 	save  %sp, -200, %sp                           <== NOT EXECUTED
  int fd = open(device, O_RDONLY);                                    
 20222e8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 20222ec:	7f ff 87 13 	call  2003f38 <open>                           <== NOT EXECUTED
 20222f0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      
  if (fd >= 0) {                                                      
 20222f4:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
 20222f8:	06 80 00 51 	bl  202243c <rtems_blkstats+0x158>             <== NOT EXECUTED
 20222fc:	01 00 00 00 	nop                                            <== NOT EXECUTED
    struct stat st;                                                   
    int rv;                                                           
                                                                      
    rv = fstat(fd, &st);                                              
 2022300:	40 00 06 9a 	call  2023d68 <fstat>                          <== NOT EXECUTED
 2022304:	92 07 bf b8 	add  %fp, -72, %o1                             <== NOT EXECUTED
    if (rv == 0) {                                                    
 2022308:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 202230c:	12 80 00 34 	bne  20223dc <rtems_blkstats+0xf8>             <== NOT EXECUTED
 2022310:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         <== NOT EXECUTED
      if (S_ISBLK(st.st_mode)) {                                      
 2022314:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        <== NOT EXECUTED
 2022318:	84 08 80 01 	and  %g2, %g1, %g2                             <== NOT EXECUTED
 202231c:	03 00 00 18 	sethi  %hi(0x6000), %g1                        <== NOT EXECUTED
 2022320:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
 2022324:	32 80 00 2a 	bne,a   20223cc <rtems_blkstats+0xe8>          <== NOT EXECUTED
 2022328:	11 00 81 61 	sethi  %hi(0x2058400), %o0                     <== NOT EXECUTED
        if (reset) {                                                  
 202232c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
 2022330:	02 80 00 11 	be  2022374 <rtems_blkstats+0x90>              <== NOT EXECUTED
 2022334:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);                   
}                                                                     
                                                                      
static inline int rtems_disk_fd_reset_device_stats(int fd)            
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);                        
 2022338:	13 08 00 10 	sethi  %hi(0x20004000), %o1                    <== NOT EXECUTED
 202233c:	40 00 09 48 	call  202485c <ioctl>                          <== NOT EXECUTED
 2022340:	92 12 62 0c 	or  %o1, 0x20c, %o1	! 2000420c <RAM_END+0x1dc0420c><== NOT EXECUTED
          rv = rtems_disk_fd_reset_device_stats(fd);                  
          if (rv != 0) {                                              
 2022344:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2022348:	02 80 00 2f 	be  2022404 <rtems_blkstats+0x120>             <== NOT EXECUTED
 202234c:	01 00 00 00 	nop                                            <== NOT EXECUTED
            fprintf(output, "error: reset stats: %s\n", strerror(errno));
 2022350:	40 00 51 c1 	call  2036a54 <__errno>                        <== NOT EXECUTED
 2022354:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2022358:	40 00 6d 8c 	call  203d988 <strerror>                       <== NOT EXECUTED
 202235c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 2022360:	13 00 81 61 	sethi  %hi(0x2058400), %o1                     <== NOT EXECUTED
 2022364:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2022368:	92 12 61 40 	or  %o1, 0x140, %o1                            <== NOT EXECUTED
 202236c:	10 80 00 24 	b  20223fc <rtems_blkstats+0x118>              <== NOT EXECUTED
 2022370:	90 10 00 18 	mov  %i0, %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);                   
 2022374:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    <== NOT EXECUTED
 2022378:	94 07 bf 98 	add  %fp, -104, %o2                            <== NOT EXECUTED
 202237c:	40 00 09 38 	call  202485c <ioctl>                          <== NOT EXECUTED
 2022380:	92 12 62 0b 	or  %o1, 0x20b, %o1                            <== NOT EXECUTED
          }                                                           
        } else {                                                      
          rtems_blkdev_stats stats;                                   
                                                                      
          rv = rtems_disk_fd_get_device_stats(fd, &stats);            
          if (rv == 0) {                                              
 2022384:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2022388:	12 80 00 08 	bne  20223a8 <rtems_blkstats+0xc4>             <== NOT EXECUTED
 202238c:	01 00 00 00 	nop                                            <== NOT EXECUTED
            rtems_blkdev_print_stats(                                 
 2022390:	90 07 bf 98 	add  %fp, -104, %o0                            <== NOT EXECUTED
 2022394:	13 00 80 dd 	sethi  %hi(0x2037400), %o1                     <== NOT EXECUTED
 2022398:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
 202239c:	40 00 00 34 	call  202246c <rtems_blkdev_print_stats>       <== NOT EXECUTED
 20223a0:	92 12 61 60 	or  %o1, 0x160, %o1                            <== NOT EXECUTED
 20223a4:	30 80 00 18 	b,a   2022404 <rtems_blkstats+0x120>           <== NOT EXECUTED
              &stats,                                                 
              (rtems_printk_plugin_t) fprintf,                        
              output                                                  
            );                                                        
          } else {                                                    
            fprintf(output, "error: get stats: %s\n", strerror(errno));
 20223a8:	40 00 51 ab 	call  2036a54 <__errno>                        <== NOT EXECUTED
 20223ac:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20223b0:	40 00 6d 76 	call  203d988 <strerror>                       <== NOT EXECUTED
 20223b4:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 20223b8:	13 00 81 61 	sethi  %hi(0x2058400), %o1                     <== NOT EXECUTED
 20223bc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20223c0:	92 12 61 58 	or  %o1, 0x158, %o1                            <== NOT EXECUTED
 20223c4:	10 80 00 0e 	b  20223fc <rtems_blkstats+0x118>              <== NOT EXECUTED
 20223c8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
          }                                                           
        }                                                             
      } else {                                                        
        fprintf(output, "error: not a block device\n");               
 20223cc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 20223d0:	40 00 54 b4 	call  20376a0 <fputs>                          <== NOT EXECUTED
 20223d4:	90 12 21 70 	or  %o0, 0x170, %o0                            <== NOT EXECUTED
 20223d8:	30 80 00 0b 	b,a   2022404 <rtems_blkstats+0x120>           <== NOT EXECUTED
      }                                                               
    } else {                                                          
      fprintf(output, "error: get file stats: %s\n", strerror(errno));
 20223dc:	40 00 51 9e 	call  2036a54 <__errno>                        <== NOT EXECUTED
 20223e0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20223e4:	40 00 6d 69 	call  203d988 <strerror>                       <== NOT EXECUTED
 20223e8:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 20223ec:	13 00 81 61 	sethi  %hi(0x2058400), %o1                     <== NOT EXECUTED
 20223f0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20223f4:	92 12 61 90 	or  %o1, 0x190, %o1                            <== NOT EXECUTED
 20223f8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 20223fc:	40 00 54 59 	call  2037560 <fprintf>                        <== NOT EXECUTED
 2022400:	01 00 00 00 	nop                                            <== NOT EXECUTED
    }                                                                 
                                                                      
    rv = close(fd);                                                   
 2022404:	40 00 05 d7 	call  2023b60 <close>                          <== NOT EXECUTED
 2022408:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    if (rv != 0) {                                                    
 202240c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2022410:	02 80 00 15 	be  2022464 <rtems_blkstats+0x180>             <== NOT EXECUTED
 2022414:	01 00 00 00 	nop                                            <== NOT EXECUTED
      fprintf(output, "error: close device: %s\n", strerror(errno));  
 2022418:	40 00 51 8f 	call  2036a54 <__errno>                        <== NOT EXECUTED
 202241c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2022420:	40 00 6d 5a 	call  203d988 <strerror>                       <== NOT EXECUTED
 2022424:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 2022428:	13 00 81 61 	sethi  %hi(0x2058400), %o1                     <== NOT EXECUTED
 202242c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2022430:	92 12 61 b0 	or  %o1, 0x1b0, %o1                            <== NOT EXECUTED
 2022434:	10 80 00 0a 	b  202245c <rtems_blkstats+0x178>              <== NOT EXECUTED
 2022438:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    }                                                                 
  } else {                                                            
    fprintf(output, "error: open device: %s\n", strerror(errno));     
 202243c:	40 00 51 86 	call  2036a54 <__errno>                        <== NOT EXECUTED
 2022440:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2022444:	40 00 6d 51 	call  203d988 <strerror>                       <== NOT EXECUTED
 2022448:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 202244c:	13 00 81 61 	sethi  %hi(0x2058400), %o1                     <== NOT EXECUTED
 2022450:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2022454:	92 12 61 d0 	or  %o1, 0x1d0, %o1                            <== NOT EXECUTED
 2022458:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 202245c:	40 00 54 41 	call  2037560 <fprintf>                        <== NOT EXECUTED
 2022460:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2022464:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2022468:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02008338 <rtems_chain_get_with_wait>: rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) {
 2008338:	9d e3 bf 98 	save  %sp, -104, %sp                           
 200833c:	30 80 00 08 	b,a   200835c <rtems_chain_get_with_wait+0x24> 
  while (                                                             
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
 2008340:	92 10 20 00 	clr  %o1                                       
 2008344:	94 10 00 1a 	mov  %i2, %o2                                  
 2008348:	7f ff fc fb 	call  2007734 <rtems_event_receive>            
 200834c:	96 07 bf fc 	add  %fp, -4, %o3                              
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
 2008350:	80 a2 20 00 	cmp  %o0, 0                                    
 2008354:	32 80 00 09 	bne,a   2008378 <rtems_chain_get_with_wait+0x40><== ALWAYS TAKEN
 2008358:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
 200835c:	40 00 01 95 	call  20089b0 <_Chain_Get>                     
 2008360:	90 10 00 18 	mov  %i0, %o0                                  
    sc == RTEMS_SUCCESSFUL                                            
      && (node = rtems_chain_get( chain )) == NULL                    
 2008364:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2008368:	02 bf ff f6 	be  2008340 <rtems_chain_get_with_wait+0x8>    
 200836c:	90 10 00 19 	mov  %i1, %o0                                  
 2008370:	90 10 20 00 	clr  %o0                                       
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
 2008374:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
 2008378:	81 c7 e0 08 	ret                                            
 200837c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

02003a40 <rtems_cpu_usage_report_with_plugin>: */ void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) {
 2003a40:	9d e3 bf 70 	save  %sp, -144, %sp                           
    uint32_t seconds, nanoseconds;                                    
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
 2003a44:	80 a6 60 00 	cmp  %i1, 0                                    
 2003a48:	02 80 00 7c 	be  2003c38 <rtems_cpu_usage_report_with_plugin+0x1f8><== NEVER TAKEN
 2003a4c:	03 00 80 81 	sethi  %hi(0x2020400), %g1                     
                                                                      
static inline void _Timestamp64_implementation_Set_to_zero(           
  Timestamp64_Control *_time                                          
)                                                                     
{                                                                     
  *_time = 0;                                                         
 2003a50:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
 2003a54:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
   *  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;            
 2003a58:	f8 18 63 d0 	ldd  [ %g1 + 0x3d0 ], %i4                      
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
 2003a5c:	90 10 00 18 	mov  %i0, %o0                                  
 2003a60:	13 00 80 74 	sethi  %hi(0x201d000), %o1                     
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
                                                                      
        (*print)(                                                     
 2003a64:	29 00 80 74 	sethi  %hi(0x201d000), %l4                     
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
 2003a68:	92 12 62 60 	or  %o1, 0x260, %o1                            
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
 2003a6c:	27 00 80 80 	sethi  %hi(0x2020000), %l3                     
 2003a70:	9f c6 40 00 	call  %i1                                      
 2003a74:	2b 00 80 74 	sethi  %hi(0x201d000), %l5                     
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
 2003a78:	a2 10 20 01 	mov  1, %l1                                    
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
                                                                      
        (*print)(                                                     
 2003a7c:	a8 15 23 d8 	or  %l4, 0x3d8, %l4                            
 2003a80:	a6 14 e1 60 	or  %l3, 0x160, %l3                            
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
 2003a84:	aa 15 63 f0 	or  %l5, 0x3f0, %l5                            
#endif                                                                
                                                                      
/*                                                                    
 *  rtems_cpu_usage_report                                            
 */                                                                   
void rtems_cpu_usage_report_with_plugin(                              
 2003a88:	83 2c 60 02 	sll  %l1, 2, %g1                               
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
 2003a8c:	05 00 80 80 	sethi  %hi(0x2020000), %g2                     
 2003a90:	84 10 a1 74 	or  %g2, 0x174, %g2	! 2020174 <_Objects_Information_table>
 2003a94:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 2003a98:	e4 00 60 04 	ld  [ %g1 + 4 ], %l2                           
    if ( information ) {                                              
 2003a9c:	80 a4 a0 00 	cmp  %l2, 0                                    
 2003aa0:	12 80 00 4a 	bne  2003bc8 <rtems_cpu_usage_report_with_plugin+0x188><== ALWAYS TAKEN
 2003aa4:	a0 10 20 01 	mov  1, %l0                                    
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
 2003aa8:	a2 04 60 01 	inc  %l1                                       <== NOT EXECUTED
 2003aac:	80 a4 60 04 	cmp  %l1, 4                                    
 2003ab0:	12 bf ff f7 	bne  2003a8c <rtems_cpu_usage_report_with_plugin+0x4c>
 2003ab4:	83 2c 60 02 	sll  %l1, 2, %g1                               
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
 2003ab8:	10 80 00 4a 	b  2003be0 <rtems_cpu_usage_report_with_plugin+0x1a0>
 2003abc:	f8 1f bf e0 	ldd  [ %fp + -32 ], %i4                        
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
        the_thread = (Thread_Control *)information->local_table[ i ]; 
 2003ac0:	83 2c 20 02 	sll  %l0, 2, %g1                               
 2003ac4:	f6 00 80 01 	ld  [ %g2 + %g1 ], %i3                         
                                                                      
        if ( !the_thread )                                            
 2003ac8:	80 a6 e0 00 	cmp  %i3, 0                                    
 2003acc:	02 80 00 3e 	be  2003bc4 <rtems_cpu_usage_report_with_plugin+0x184><== NEVER TAKEN
 2003ad0:	92 10 20 0d 	mov  0xd, %o1                                  
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
 2003ad4:	d0 06 e0 08 	ld  [ %i3 + 8 ], %o0                           
 2003ad8:	40 00 13 92 	call  2008920 <rtems_object_get_name>          
 2003adc:	94 07 bf f0 	add  %fp, -16, %o2                             
                                                                      
        (*print)(                                                     
 2003ae0:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
 2003ae4:	90 10 00 18 	mov  %i0, %o0                                  
 2003ae8:	92 10 00 14 	mov  %l4, %o1                                  
 2003aec:	9f c6 40 00 	call  %i1                                      
 2003af0:	96 07 bf f0 	add  %fp, -16, %o3                             
                                                                      
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
 2003af4:	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 ) {  
 2003af8:	03 00 80 81 	sethi  %hi(0x2020400), %g1                     
                                                                      
          /*                                                          
           * If this is the currently executing thread, account for time
           * since the last context switch.                           
           */                                                         
          ran = the_thread->cpu_time_used;                            
 2003afc:	c4 3f bf e8 	std  %g2, [ %fp + -24 ]                        
    Thread_Control    *the_thread,                                    
    Timestamp_Control *time_of_context_switch                         
  )                                                                   
  {                                                                   
    #ifndef RTEMS_SMP                                                 
      if ( _Thread_Executing->Object.id == the_thread->Object.id ) {  
 2003b00:	82 10 63 70 	or  %g1, 0x370, %g1                            
 2003b04:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 2003b08:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
 2003b0c:	c4 06 e0 08 	ld  [ %i3 + 8 ], %g2                           
 2003b10:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2003b14:	12 80 00 4b 	bne  2003c40 <rtems_cpu_usage_report_with_plugin+0x200>
 2003b18:	90 07 bf d8 	add  %fp, -40, %o0                             
        *time_of_context_switch = _Thread_Time_of_last_context_switch;
 2003b1c:	f4 18 60 20 	ldd  [ %g1 + 0x20 ], %i2                       
 2003b20:	40 00 18 96 	call  2009d78 <_TOD_Get_with_nanoseconds>      
 2003b24:	92 10 00 13 	mov  %l3, %o1                                  
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
 2003b28:	d8 1f bf e8 	ldd  [ %fp + -24 ], %o4                        
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
 2003b2c:	c4 1f bf d8 	ldd  [ %fp + -40 ], %g2                        
 2003b30:	86 a0 c0 1b 	subcc  %g3, %i3, %g3                           
 2003b34:	84 60 80 1a 	subx  %g2, %i2, %g2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
 2003b38:	96 83 40 03 	addcc  %o5, %g3, %o3                           
 2003b3c:	94 43 00 02 	addx  %o4, %g2, %o2                            
 2003b40:	d4 3f bf e8 	std  %o2, [ %fp + -24 ]                        
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
 2003b44:	c4 1f bf d8 	ldd  [ %fp + -40 ], %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 );            
 2003b48:	90 07 bf e8 	add  %fp, -24, %o0                             
 2003b4c:	86 a0 c0 1d 	subcc  %g3, %i5, %g3                           
 2003b50:	84 60 80 1c 	subx  %g2, %i4, %g2                            
 2003b54:	92 07 bf e0 	add  %fp, -32, %o1                             
 2003b58:	c4 3f bf e0 	std  %g2, [ %fp + -32 ]                        
 2003b5c:	94 07 bf d0 	add  %fp, -48, %o2                             
 2003b60:	40 00 22 15 	call  200c3b4 <_Timestamp64_Divide>            
 2003b64:	96 07 bf d4 	add  %fp, -44, %o3                             
                                                                      
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
 2003b68:	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);                           
 2003b6c:	94 10 20 00 	clr  %o2                                       
 2003b70:	90 10 00 1a 	mov  %i2, %o0                                  
 2003b74:	92 10 00 1b 	mov  %i3, %o1                                  
 2003b78:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2003b7c:	40 00 5c 27 	call  201ac18 <__divdi3>                       
 2003b80:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
 2003b84:	94 10 20 00 	clr  %o2                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
 2003b88:	ac 10 00 09 	mov  %o1, %l6                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
 2003b8c:	90 10 00 1a 	mov  %i2, %o0                                  
 2003b90:	92 10 00 1b 	mov  %i3, %o1                                  
 2003b94:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2003b98:	40 00 5d 0b 	call  201afc4 <__moddi3>                       
 2003b9c:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
 2003ba0:	90 10 00 09 	mov  %o1, %o0                                  
 2003ba4:	40 00 5a c5 	call  201a6b8 <.udiv>                          
 2003ba8:	92 10 23 e8 	mov  0x3e8, %o1                                
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
 2003bac:	d8 1f bf d0 	ldd  [ %fp + -48 ], %o4                        
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
 2003bb0:	96 10 00 08 	mov  %o0, %o3                                  
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
 2003bb4:	92 10 00 15 	mov  %l5, %o1                                  
 2003bb8:	90 10 00 18 	mov  %i0, %o0                                  
 2003bbc:	9f c6 40 00 	call  %i1                                      
 2003bc0:	94 10 00 16 	mov  %l6, %o2                                  
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( information ) {                                              
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
 2003bc4:	a0 04 20 01 	inc  %l0                                       
 2003bc8:	c2 14 a0 10 	lduh  [ %l2 + 0x10 ], %g1                      
 2003bcc:	80 a4 00 01 	cmp  %l0, %g1                                  
 2003bd0:	28 bf ff bc 	bleu,a   2003ac0 <rtems_cpu_usage_report_with_plugin+0x80>
 2003bd4:	c4 04 a0 1c 	ld  [ %l2 + 0x1c ], %g2                        
       " ID         | NAME                                   | TICKS         | PERCENT\n"
     #endif                                                           
     "------------+----------------------------------------+---------------+---------\n"
  );                                                                  
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
 2003bd8:	10 bf ff b5 	b  2003aac <rtems_cpu_usage_report_with_plugin+0x6c>
 2003bdc:	a2 04 60 01 	inc  %l1                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
 2003be0:	94 10 20 00 	clr  %o2                                       
 2003be4:	90 10 00 1c 	mov  %i4, %o0                                  
 2003be8:	92 10 00 1d 	mov  %i5, %o1                                  
 2003bec:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2003bf0:	40 00 5c 0a 	call  201ac18 <__divdi3>                       
 2003bf4:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
 2003bf8:	94 10 20 00 	clr  %o2                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
 2003bfc:	b6 10 00 09 	mov  %o1, %i3                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
 2003c00:	90 10 00 1c 	mov  %i4, %o0                                  
 2003c04:	92 10 00 1d 	mov  %i5, %o1                                  
 2003c08:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2003c0c:	40 00 5c ee 	call  201afc4 <__moddi3>                       
 2003c10:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
    nanoseconds = _Timestamp_Get_nanoseconds( &total ) /              
 2003c14:	90 10 00 09 	mov  %o1, %o0                                  
 2003c18:	40 00 5a a8 	call  201a6b8 <.udiv>                          
 2003c1c:	92 10 23 e8 	mov  0x3e8, %o1                                
      TOD_NANOSECONDS_PER_MICROSECOND;                                
    (*print)(                                                         
 2003c20:	13 00 80 75 	sethi  %hi(0x201d400), %o1                     
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
    nanoseconds = _Timestamp_Get_nanoseconds( &total ) /              
 2003c24:	96 10 00 08 	mov  %o0, %o3                                  
      TOD_NANOSECONDS_PER_MICROSECOND;                                
    (*print)(                                                         
 2003c28:	92 12 60 08 	or  %o1, 8, %o1                                
 2003c2c:	90 10 00 18 	mov  %i0, %o0                                  
 2003c30:	9f c6 40 00 	call  %i1                                      
 2003c34:	94 10 00 1b 	mov  %i3, %o2                                  
 2003c38:	81 c7 e0 08 	ret                                            
 2003c3c:	81 e8 00 00 	restore                                        
 2003c40:	40 00 18 4e 	call  2009d78 <_TOD_Get_with_nanoseconds>      
 2003c44:	92 10 00 13 	mov  %l3, %o1                                  
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
 2003c48:	10 bf ff c0 	b  2003b48 <rtems_cpu_usage_report_with_plugin+0x108>
 2003c4c:	c4 1f bf d8 	ldd  [ %fp + -40 ], %g2                        
                                                                      

0200f584 <rtems_deviceio_errno>: [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) {
 200f584:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (sc == RTEMS_SUCCESSFUL) {                                       
 200f588:	80 a6 20 00 	cmp  %i0, 0                                    
 200f58c:	02 80 00 0d 	be  200f5c0 <rtems_deviceio_errno+0x3c>        
 200f590:	82 10 20 00 	clr  %g1                                       
    return 0;                                                         
  } else {                                                            
    int eno = EINVAL;                                                 
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
 200f594:	80 a6 20 1c 	cmp  %i0, 0x1c                                 
 200f598:	18 80 00 06 	bgu  200f5b0 <rtems_deviceio_errno+0x2c>       <== NEVER TAKEN
 200f59c:	ba 10 20 16 	mov  0x16, %i5                                 
      eno = status_code_to_errno [sc];                                
 200f5a0:	b1 2e 20 02 	sll  %i0, 2, %i0                               
 200f5a4:	03 00 80 6e 	sethi  %hi(0x201b800), %g1                     
 200f5a8:	82 10 63 a4 	or  %g1, 0x3a4, %g1	! 201bba4 <status_code_to_errno>
 200f5ac:	fa 00 40 18 	ld  [ %g1 + %i0 ], %i5                         
    }                                                                 
                                                                      
    errno = eno;                                                      
 200f5b0:	40 00 00 2f 	call  200f66c <__errno>                        
 200f5b4:	01 00 00 00 	nop                                            
                                                                      
    return -1;                                                        
 200f5b8:	82 10 3f ff 	mov  -1, %g1	! ffffffff <RAM_END+0xfdbfffff>   
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
      eno = status_code_to_errno [sc];                                
    }                                                                 
                                                                      
    errno = eno;                                                      
 200f5bc:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
    return -1;                                                        
  }                                                                   
}                                                                     
 200f5c0:	81 c7 e0 08 	ret                                            
 200f5c4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02003968 <rtems_disk_create_log>: dev_t phys, rtems_blkdev_bnum block_begin, rtems_blkdev_bnum block_count, const char *name ) {
 2003968:	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;                                       
 200396c:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  char *alloc_name = NULL;                                            
                                                                      
  sc = disk_lock();                                                   
 2003970:	7f ff ff 11 	call  20035b4 <disk_lock>                      
 2003974:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003978:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 200397c:	32 80 00 2b 	bne,a   2003a28 <rtems_disk_create_log+0xc0>   <== NEVER TAKEN
 2003980:	b0 10 00 10 	mov  %l0, %i0                                  <== NOT EXECUTED
    return sc;                                                        
  }                                                                   
                                                                      
  phys_dd = get_disk_entry(phys, true);                               
 2003984:	92 10 00 1b 	mov  %i3, %o1                                  
 2003988:	90 10 00 1a 	mov  %i2, %o0                                  
 200398c:	7f ff fe cf 	call  20034c8 <get_disk_entry>                 
 2003990:	94 10 20 01 	mov  1, %o2                                    
  if (phys_dd == NULL) {                                              
 2003994:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2003998:	12 80 00 06 	bne  20039b0 <rtems_disk_create_log+0x48>      
 200399c:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2                        
    disk_unlock();                                                    
 20039a0:	7f ff ff 14 	call  20035f0 <disk_unlock>                    
 20039a4:	a0 10 20 04 	mov  4, %l0                                    
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20039a8:	81 c7 e0 08 	ret                                            
 20039ac:	91 e8 00 10 	restore  %g0, %l0, %o0                         
    disk_unlock();                                                    
                                                                      
    return RTEMS_INVALID_ID;                                          
  }                                                                   
                                                                      
  sc = create_disk(dev, name, &dd, &alloc_name);                      
 20039b0:	90 10 00 18 	mov  %i0, %o0                                  
 20039b4:	92 10 00 19 	mov  %i1, %o1                                  
 20039b8:	96 07 bf f8 	add  %fp, -8, %o3                              
 20039bc:	7f ff ff 1a 	call  2003624 <create_disk>                    
 20039c0:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
 20039c4:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 20039c8:	12 80 00 16 	bne  2003a20 <rtems_disk_create_log+0xb8>      
 20039cc:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_log(                                           
 20039d0:	92 10 00 1b 	mov  %i3, %o1                                  
 20039d4:	94 10 00 1c 	mov  %i4, %o2                                  
 20039d8:	40 00 2e ea 	call  200f580 <rtems_disk_init_log>            
 20039dc:	96 10 00 1d 	mov  %i5, %o3                                  
    phys_dd,                                                          
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
 20039e0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  dd->name = alloc_name;                                              
 20039e4:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    phys_dd,                                                          
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
 20039e8:	f0 38 40 00 	std  %i0, [ %g1 ]                              
  dd->name = alloc_name;                                              
 20039ec:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
  ++phys_dd->uses;                                                    
 20039f0:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_log(                                           
 20039f4:	a0 10 00 08 	mov  %o0, %l0                                  
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
                                                                      
  ++phys_dd->uses;                                                    
 20039f8:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
 20039fc:	80 a2 20 00 	cmp  %o0, 0                                    
 2003a00:	02 80 00 08 	be  2003a20 <rtems_disk_create_log+0xb8>       
 2003a04:	c4 26 e0 14 	st  %g2, [ %i3 + 0x14 ]                        
    dd->ioctl = null_handler;                                         
 2003a08:	05 00 80 0d 	sethi  %hi(0x2003400), %g2                     
 2003a0c:	84 10 a1 58 	or  %g2, 0x158, %g2	! 2003558 <null_handler>   
    rtems_disk_delete(dev);                                           
 2003a10:	90 10 00 18 	mov  %i0, %o0                                  
  dd->name = alloc_name;                                              
                                                                      
  ++phys_dd->uses;                                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
 2003a14:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
    rtems_disk_delete(dev);                                           
 2003a18:	7f ff ff 6c 	call  20037c8 <rtems_disk_delete>              
 2003a1c:	92 10 00 19 	mov  %i1, %o1                                  
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
 2003a20:	7f ff fe f4 	call  20035f0 <disk_unlock>                    
 2003a24:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003a28:	81 c7 e0 08 	ret                                            
 2003a2c:	81 e8 00 00 	restore                                        
                                                                      

02003a30 <rtems_disk_create_phys>: rtems_blkdev_bnum block_count, rtems_block_device_ioctl handler, void *driver_data, const char *name ) {
 2003a30:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_disk_device *dd = NULL;                                       
 2003a34:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  char *alloc_name = NULL;                                            
 2003a38:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  if (handler == NULL) {                                              
 2003a3c:	80 a7 20 00 	cmp  %i4, 0                                    
 2003a40:	02 80 00 23 	be  2003acc <rtems_disk_create_phys+0x9c>      
 2003a44:	a0 10 20 09 	mov  9, %l0                                    
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
 2003a48:	7f ff fe db 	call  20035b4 <disk_lock>                      
 2003a4c:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003a50:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2003a54:	12 80 00 1e 	bne  2003acc <rtems_disk_create_phys+0x9c>     <== NEVER TAKEN
 2003a58:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2                        
    return sc;                                                        
  }                                                                   
                                                                      
  sc = create_disk(dev, name, &dd, &alloc_name);                      
 2003a5c:	90 10 00 18 	mov  %i0, %o0                                  
 2003a60:	92 10 00 19 	mov  %i1, %o1                                  
 2003a64:	96 07 bf f8 	add  %fp, -8, %o3                              
 2003a68:	7f ff fe ef 	call  2003624 <create_disk>                    
 2003a6c:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003a70:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2003a74:	12 80 00 14 	bne  2003ac4 <rtems_disk_create_phys+0x94>     
 2003a78:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_phys(                                          
 2003a7c:	92 10 00 1a 	mov  %i2, %o1                                  
 2003a80:	94 10 00 1b 	mov  %i3, %o2                                  
 2003a84:	96 10 00 1c 	mov  %i4, %o3                                  
 2003a88:	40 00 2e a4 	call  200f518 <rtems_disk_init_phys>           
 2003a8c:	98 10 00 1d 	mov  %i5, %o4                                  
    block_count,                                                      
    handler,                                                          
    driver_data                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
 2003a90:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  dd->name = alloc_name;                                              
 2003a94:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    block_count,                                                      
    handler,                                                          
    driver_data                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
 2003a98:	f0 38 40 00 	std  %i0, [ %g1 ]                              
  dd->name = alloc_name;                                              
 2003a9c:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003aa0:	80 a2 20 00 	cmp  %o0, 0                                    
 2003aa4:	02 80 00 08 	be  2003ac4 <rtems_disk_create_phys+0x94>      
 2003aa8:	a0 10 00 08 	mov  %o0, %l0                                  
    dd->ioctl = null_handler;                                         
 2003aac:	05 00 80 0d 	sethi  %hi(0x2003400), %g2                     
 2003ab0:	84 10 a1 58 	or  %g2, 0x158, %g2	! 2003558 <null_handler>   
    rtems_disk_delete(dev);                                           
 2003ab4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
 2003ab8:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
    rtems_disk_delete(dev);                                           
 2003abc:	7f ff ff 43 	call  20037c8 <rtems_disk_delete>              
 2003ac0:	92 10 00 19 	mov  %i1, %o1                                  
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
 2003ac4:	7f ff fe cb 	call  20035f0 <disk_unlock>                    
 2003ac8:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003acc:	81 c7 e0 08 	ret                                            
 2003ad0:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

020037c8 <rtems_disk_delete>: } } rtems_status_code rtems_disk_delete(dev_t dev) {
 20037c8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *dd = NULL;                                       
                                                                      
  sc = disk_lock();                                                   
 20037cc:	7f ff ff 7a 	call  20035b4 <disk_lock>                      
 20037d0:	b8 10 00 18 	mov  %i0, %i4                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 20037d4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20037d8:	12 80 00 0a 	bne  2003800 <rtems_disk_delete+0x38>          <== NEVER TAKEN
 20037dc:	90 10 00 1c 	mov  %i4, %o0                                  
    return sc;                                                        
  }                                                                   
                                                                      
  dd = get_disk_entry(dev, true);                                     
 20037e0:	92 10 00 19 	mov  %i1, %o1                                  
 20037e4:	7f ff ff 39 	call  20034c8 <get_disk_entry>                 
 20037e8:	94 10 20 01 	mov  1, %o2                                    
  if (dd == NULL) {                                                   
 20037ec:	82 92 20 00 	orcc  %o0, 0, %g1                              
 20037f0:	32 80 00 06 	bne,a   2003808 <rtems_disk_delete+0x40>       <== ALWAYS TAKEN
 20037f4:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
    disk_unlock();                                                    
 20037f8:	7f ff ff 7e 	call  20035f0 <disk_unlock>                    <== NOT EXECUTED
 20037fc:	b0 10 20 04 	mov  4, %i0                                    <== NOT EXECUTED
 2003800:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003804:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    return RTEMS_INVALID_ID;                                          
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
 2003808:	84 10 20 01 	mov  1, %g2                                    
 200380c:	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) {                                       
 2003810:	c4 0f 60 40 	ldub  [ %i5 + 0x40 ], %g2                      
 2003814:	80 a0 a0 00 	cmp  %g2, 0                                    
 2003818:	22 80 00 41 	be,a   200391c <rtems_disk_delete+0x154>       
 200381c:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
    dev_t dev = physical_disk->dev;                                   
 2003820:	e2 07 40 00 	ld  [ %i5 ], %l1                               
 2003824:	e4 07 60 04 	ld  [ %i5 + 4 ], %l2                           
    unsigned deleted_count = 0;                                       
 2003828:	b4 10 20 00 	clr  %i2                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
 200382c:	b8 10 20 00 	clr  %i4                                       
 2003830:	21 00 80 85 	sethi  %hi(0x2021400), %l0                     
      rtems_disk_device_table *dtab = disktab + major;                
 2003834:	27 00 80 85 	sethi  %hi(0x2021400), %l3                     
          if (dd->uses == 0) {                                        
            ++deleted_count;                                          
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
          } else {                                                    
            dd->deleted = true;                                       
 2003838:	10 80 00 26 	b  20038d0 <rtems_disk_delete+0x108>           
 200383c:	a8 10 20 01 	mov  1, %l4                                    
    }                                                                 
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_delete(dev_t dev)                                          
 2003840:	83 2f 20 03 	sll  %i4, 3, %g1                               
    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) {                  
 2003844:	b6 10 20 00 	clr  %i3                                       
  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;                
 2003848:	10 80 00 1d 	b  20038bc <rtems_disk_delete+0xf4>            
 200384c:	b2 06 40 01 	add  %i1, %g1, %i1                             
    }                                                                 
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_delete(dev_t dev)                                          
 2003850:	85 2e e0 02 	sll  %i3, 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];                  
 2003854:	d0 00 c0 02 	ld  [ %g3 + %g2 ], %o0                         
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
 2003858:	80 a2 20 00 	cmp  %o0, 0                                    
 200385c:	22 80 00 18 	be,a   20038bc <rtems_disk_delete+0xf4>        
 2003860:	b6 06 e0 01 	inc  %i3                                       
 2003864:	c8 02 20 08 	ld  [ %o0 + 8 ], %g4                           
 2003868:	de 01 00 00 	ld  [ %g4 ], %o7                               
 200386c:	80 a3 c0 11 	cmp  %o7, %l1                                  
 2003870:	32 80 00 13 	bne,a   20038bc <rtems_disk_delete+0xf4>       <== NEVER TAKEN
 2003874:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
 2003878:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
 200387c:	80 a1 00 12 	cmp  %g4, %l2                                  
 2003880:	32 80 00 0f 	bne,a   20038bc <rtems_disk_delete+0xf4>       <== NEVER TAKEN
 2003884:	b6 06 e0 01 	inc  %i3                                       <== NOT EXECUTED
 2003888:	80 a2 00 1d 	cmp  %o0, %i5                                  
 200388c:	22 80 00 0c 	be,a   20038bc <rtems_disk_delete+0xf4>        
 2003890:	b6 06 e0 01 	inc  %i3                                       
          if (dd->uses == 0) {                                        
 2003894:	c8 02 20 14 	ld  [ %o0 + 0x14 ], %g4                        
 2003898:	80 a1 20 00 	cmp  %g4, 0                                    
 200389c:	32 80 00 07 	bne,a   20038b8 <rtems_disk_delete+0xf0>       
 20038a0:	e8 2a 20 40 	stb  %l4, [ %o0 + 0x40 ]                       
            ++deleted_count;                                          
 20038a4:	b4 06 a0 01 	inc  %i2                                       
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
 20038a8:	7f ff ff 2e 	call  2003560 <free_disk_device>               
 20038ac:	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) {                  
 20038b0:	10 80 00 03 	b  20038bc <rtems_disk_delete+0xf4>            
 20038b4:	b6 06 e0 01 	inc  %i3                                       
 20038b8:	b6 06 e0 01 	inc  %i3                                       
 20038bc:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 20038c0:	80 a6 c0 01 	cmp  %i3, %g1                                  
 20038c4:	2a bf ff e3 	bcs,a   2003850 <rtems_disk_delete+0x88>       
 20038c8:	c6 06 40 00 	ld  [ %i1 ], %g3                               
                                                                      
  if (physical_disk->deleted) {                                       
    dev_t dev = physical_disk->dev;                                   
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
 20038cc:	b8 07 20 01 	inc  %i4                                       
 20038d0:	c2 04 21 30 	ld  [ %l0 + 0x130 ], %g1                       
 20038d4:	80 a7 00 01 	cmp  %i4, %g1                                  
 20038d8:	2a bf ff da 	bcs,a   2003840 <rtems_disk_delete+0x78>       
 20038dc:	f2 04 e1 34 	ld  [ %l3 + 0x134 ], %i1                       
          }                                                           
        }                                                             
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
 20038e0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 20038e4:	b4 20 40 1a 	sub  %g1, %i2, %i2                             
    if (physical_disk->uses == 0) {                                   
 20038e8:	80 a6 a0 00 	cmp  %i2, 0                                    
 20038ec:	12 80 00 1b 	bne  2003958 <rtems_disk_delete+0x190>         
 20038f0:	f4 27 60 14 	st  %i2, [ %i5 + 0x14 ]                        
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
 20038f4:	c4 07 40 00 	ld  [ %i5 ], %g2                               
      disktab [major].minor [minor] = NULL;                           
 20038f8:	07 00 80 85 	sethi  %hi(0x2021400), %g3                     
 20038fc:	c6 00 e1 34 	ld  [ %g3 + 0x134 ], %g3	! 2021534 <disktab>   
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
 2003900:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
      disktab [major].minor [minor] = NULL;                           
 2003904:	85 28 a0 03 	sll  %g2, 3, %g2                               
 2003908:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
 200390c:	83 28 60 02 	sll  %g1, 2, %g1                               
      free_disk_device(physical_disk);                                
 2003910:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
      disktab [major].minor [minor] = NULL;                           
 2003914:	10 80 00 0f 	b  2003950 <rtems_disk_delete+0x188>           
 2003918:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
 200391c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2003920:	12 80 00 0e 	bne  2003958 <rtems_disk_delete+0x190>         <== NEVER TAKEN
 2003924:	07 00 80 85 	sethi  %hi(0x2021400), %g3                     
      --physical_disk->uses;                                          
 2003928:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 200392c:	84 00 bf ff 	add  %g2, -1, %g2                              
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
 2003930:	c6 00 e1 34 	ld  [ %g3 + 0x134 ], %g3                       
      disktab [major].minor [minor] = NULL;                           
      free_disk_device(physical_disk);                                
    }                                                                 
  } else {                                                            
    if (disk_to_remove->uses == 0) {                                  
      --physical_disk->uses;                                          
 2003934:	c4 27 60 14 	st  %g2, [ %i5 + 0x14 ]                        
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
 2003938:	c4 00 40 00 	ld  [ %g1 ], %g2                               
 200393c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      disktab [major].minor [minor] = NULL;                           
 2003940:	85 28 a0 03 	sll  %g2, 3, %g2                               
 2003944:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
 2003948:	83 28 60 02 	sll  %g1, 2, %g1                               
 200394c:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
      free_disk_device(disk_to_remove);                               
 2003950:	7f ff ff 04 	call  2003560 <free_disk_device>               
 2003954:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
 2003958:	7f ff ff 26 	call  20035f0 <disk_unlock>                    
 200395c:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003960:	81 c7 e0 08 	ret                                            
 2003964:	81 e8 00 00 	restore                                        
                                                                      

02003c88 <rtems_disk_io_initialize>: rtems_status_code rtems_disk_io_initialize(void) {
 2003c88:	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) {                                             
 2003c8c:	39 00 80 85 	sethi  %hi(0x2021400), %i4                     
 2003c90:	c2 07 21 30 	ld  [ %i4 + 0x130 ], %g1	! 2021530 <disktab_size>
 2003c94:	80 a0 60 00 	cmp  %g1, 0                                    
 2003c98:	12 80 00 19 	bne  2003cfc <rtems_disk_io_initialize+0x74>   
 2003c9c:	b0 10 20 00 	clr  %i0                                       
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
 2003ca0:	90 10 20 08 	mov  8, %o0                                    
 2003ca4:	92 10 20 08 	mov  8, %o1                                    
 2003ca8:	40 00 02 09 	call  20044cc <calloc>                         
 2003cac:	3b 00 80 85 	sethi  %hi(0x2021400), %i5                     
 2003cb0:	d0 27 61 34 	st  %o0, [ %i5 + 0x134 ]	! 2021534 <disktab>   
  if (disktab == NULL) {                                              
 2003cb4:	80 a2 20 00 	cmp  %o0, 0                                    
 2003cb8:	02 80 00 11 	be  2003cfc <rtems_disk_io_initialize+0x74>    <== NEVER TAKEN
 2003cbc:	b0 10 20 1a 	mov  0x1a, %i0                                 
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  diskdevs_protected = false;                                         
 2003cc0:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
  sc = rtems_semaphore_create(                                        
 2003cc4:	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;                                         
 2003cc8:	c0 28 61 28 	clrb  [ %g1 + 0x128 ]                          
  sc = rtems_semaphore_create(                                        
 2003ccc:	90 12 21 56 	or  %o0, 0x156, %o0                            
 2003cd0:	92 10 20 01 	mov  1, %o1                                    
 2003cd4:	94 10 20 10 	mov  0x10, %o2                                 
 2003cd8:	96 10 20 00 	clr  %o3                                       
 2003cdc:	37 00 80 85 	sethi  %hi(0x2021400), %i3                     
 2003ce0:	40 00 12 e9 	call  2008884 <rtems_semaphore_create>         
 2003ce4:	98 16 e1 2c 	or  %i3, 0x12c, %o4	! 202152c <diskdevs_mutex> 
    RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY   
      | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,                      
    0,                                                                
    &diskdevs_mutex                                                   
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003ce8:	80 a2 20 00 	cmp  %o0, 0                                    
 2003cec:	02 80 00 06 	be  2003d04 <rtems_disk_io_initialize+0x7c>    <== ALWAYS TAKEN
 2003cf0:	01 00 00 00 	nop                                            
    free(disktab);                                                    
 2003cf4:	40 00 02 ca 	call  200481c <free>                           <== NOT EXECUTED
 2003cf8:	d0 07 61 34 	ld  [ %i5 + 0x134 ], %o0                       <== NOT EXECUTED
                                                                      
    return RTEMS_NO_MEMORY;                                           
 2003cfc:	81 c7 e0 08 	ret                                            
 2003d00:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
 2003d04:	40 00 29 93 	call  200e350 <rtems_bdbuf_init>               
 2003d08:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003d0c:	80 a2 20 00 	cmp  %o0, 0                                    
 2003d10:	02 80 00 09 	be  2003d34 <rtems_disk_io_initialize+0xac>    <== ALWAYS TAKEN
 2003d14:	82 10 20 08 	mov  8, %g1                                    
    rtems_semaphore_delete(diskdevs_mutex);                           
 2003d18:	d0 06 e1 2c 	ld  [ %i3 + 0x12c ], %o0                       <== NOT EXECUTED
 2003d1c:	40 00 13 48 	call  2008a3c <rtems_semaphore_delete>         <== NOT EXECUTED
 2003d20:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
    free(disktab);                                                    
 2003d24:	40 00 02 be 	call  200481c <free>                           <== NOT EXECUTED
 2003d28:	d0 07 61 34 	ld  [ %i5 + 0x134 ], %o0                       <== NOT EXECUTED
                                                                      
    return RTEMS_UNSATISFIED;                                         
 2003d2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003d30:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  disktab_size = size;                                                
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 2003d34:	b0 10 20 00 	clr  %i0                                       
    free(disktab);                                                    
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  disktab_size = size;                                                
 2003d38:	c2 27 21 30 	st  %g1, [ %i4 + 0x130 ]                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 2003d3c:	81 c7 e0 08 	ret                                            
 2003d40:	81 e8 00 00 	restore                                        
                                                                      

02003b98 <rtems_disk_next>: rtems_disk_device * rtems_disk_next(dev_t dev) {
 2003b98:	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) {                                            
 2003b9c:	80 a6 3f ff 	cmp  %i0, -1                                   
 2003ba0:	12 80 00 05 	bne  2003bb4 <rtems_disk_next+0x1c>            
 2003ba4:	b8 06 60 01 	add  %i1, 1, %i4                               
 2003ba8:	80 a6 7f ff 	cmp  %i1, -1                                   
 2003bac:	22 80 00 0b 	be,a   2003bd8 <rtems_disk_next+0x40>          <== ALWAYS TAKEN
 2003bb0:	b8 10 20 00 	clr  %i4                                       
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
    /* If minor wraps around */                                       
    if ((minor + 1) < minor) {                                        
 2003bb4:	80 a7 00 19 	cmp  %i4, %i1                                  
 2003bb8:	1a 80 00 09 	bcc  2003bdc <rtems_disk_next+0x44>            <== ALWAYS TAKEN
 2003bbc:	ba 10 00 18 	mov  %i0, %i5                                  
      /* If major wraps around */                                     
      if ((major + 1) < major) {                                      
 2003bc0:	ba 06 20 01 	add  %i0, 1, %i5                               <== NOT EXECUTED
 2003bc4:	80 a7 40 18 	cmp  %i5, %i0                                  <== NOT EXECUTED
 2003bc8:	1a 80 00 05 	bcc  2003bdc <rtems_disk_next+0x44>            <== NOT EXECUTED
 2003bcc:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
    disk_unlock();                                                    
                                                                      
    return NULL;                                                      
 2003bd0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003bd4:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
 2003bd8:	ba 10 20 00 	clr  %i5                                       
    } else {                                                          
      ++minor;                                                        
    }                                                                 
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
 2003bdc:	7f ff fe 76 	call  20035b4 <disk_lock>                      
 2003be0:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
 2003be4:	80 a2 20 00 	cmp  %o0, 0                                    
 2003be8:	12 80 00 08 	bne  2003c08 <rtems_disk_next+0x70>            <== NEVER TAKEN
 2003bec:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
 2003bf0:	c4 00 61 30 	ld  [ %g1 + 0x130 ], %g2	! 2021530 <disktab_size>
 2003bf4:	80 a7 40 02 	cmp  %i5, %g2                                  
 2003bf8:	0a 80 00 06 	bcs  2003c10 <rtems_disk_next+0x78>            <== ALWAYS TAKEN
 2003bfc:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    disk_unlock();                                                    
 2003c00:	7f ff fe 7c 	call  20035f0 <disk_unlock>                    
 2003c04:	01 00 00 00 	nop                                            
                                                                      
    return NULL;                                                      
 2003c08:	81 c7 e0 08 	ret                                            
 2003c0c:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
 2003c10:	c6 00 61 34 	ld  [ %g1 + 0x134 ], %g3                       
 2003c14:	b7 2f 60 03 	sll  %i5, 3, %i3                               
 2003c18:	b6 00 c0 1b 	add  %g3, %i3, %i3                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
 2003c1c:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 2003c20:	80 a0 60 00 	cmp  %g1, 0                                    
 2003c24:	22 80 00 07 	be,a   2003c40 <rtems_disk_next+0xa8>          
 2003c28:	ba 07 60 01 	inc  %i5                                       
 2003c2c:	c8 06 e0 04 	ld  [ %i3 + 4 ], %g4                           
 2003c30:	80 a7 00 04 	cmp  %i4, %g4                                  
 2003c34:	0a 80 00 09 	bcs  2003c58 <rtems_disk_next+0xc0>            
 2003c38:	b5 2f 20 02 	sll  %i4, 2, %i2                               
       minor = 0;                                                     
       ++major;                                                       
 2003c3c:	ba 07 60 01 	inc  %i5                                       
       if (major >= disktab_size) {                                   
 2003c40:	80 a7 40 02 	cmp  %i5, %g2                                  
 2003c44:	1a bf ff ef 	bcc  2003c00 <rtems_disk_next+0x68>            
 2003c48:	b7 2f 60 03 	sll  %i5, 3, %i3                               
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
       minor = 0;                                                     
 2003c4c:	b8 10 20 00 	clr  %i4                                       
       if (major >= disktab_size) {                                   
         disk_unlock();                                               
                                                                      
         return NULL;                                                 
       }                                                              
       dtab = disktab + major;                                        
 2003c50:	10 bf ff f3 	b  2003c1c <rtems_disk_next+0x84>              
 2003c54:	b6 00 c0 1b 	add  %g3, %i3, %i3                             
    } else if (dtab->minor [minor] == NULL) {                         
 2003c58:	c2 00 40 1a 	ld  [ %g1 + %i2 ], %g1                         
 2003c5c:	80 a0 60 00 	cmp  %g1, 0                                    
 2003c60:	02 bf ff ef 	be  2003c1c <rtems_disk_next+0x84>             
 2003c64:	b8 07 20 01 	inc  %i4                                       
      ++minor;                                                        
    } else {                                                          
      ++dtab->minor [minor]->uses;                                    
 2003c68:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
 2003c6c:	84 00 a0 01 	inc  %g2                                       
      disk_unlock();                                                  
 2003c70:	7f ff fe 60 	call  20035f0 <disk_unlock>                    
 2003c74:	c4 20 60 14 	st  %g2, [ %g1 + 0x14 ]                        
                                                                      
      return dtab->minor [minor];                                     
 2003c78:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 2003c7c:	f0 00 40 1a 	ld  [ %g1 + %i2 ], %i0                         
    }                                                                 
  }                                                                   
}                                                                     
 2003c80:	81 c7 e0 08 	ret                                            
 2003c84:	81 e8 00 00 	restore                                        
                                                                      

02003ad4 <rtems_disk_obtain>: return RTEMS_SUCCESSFUL; } rtems_disk_device * rtems_disk_obtain(dev_t dev) {
 2003ad4:	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);                                     
 2003ad8:	7f ff fc cd 	call  2002e0c <sparc_disable_interrupts>       
 2003adc:	b8 10 00 18 	mov  %i0, %i4                                  
 2003ae0:	b6 10 00 08 	mov  %o0, %i3                                  
  if (!diskdevs_protected) {                                          
 2003ae4:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 2003ae8:	c2 08 61 28 	ldub  [ %g1 + 0x128 ], %g1	! 2021528 <diskdevs_protected>
 2003aec:	80 a0 60 00 	cmp  %g1, 0                                    
 2003af0:	12 80 00 0a 	bne  2003b18 <rtems_disk_obtain+0x44>          <== NEVER TAKEN
 2003af4:	92 10 00 19 	mov  %i1, %o1                                  
    /* Frequent and quickest case */                                  
    dd = get_disk_entry(dev, false);                                  
 2003af8:	90 10 00 18 	mov  %i0, %o0                                  
 2003afc:	7f ff fe 73 	call  20034c8 <get_disk_entry>                 
 2003b00:	94 10 20 00 	clr  %o2                                       
 2003b04:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_interrupt_enable(level);                                    
 2003b08:	7f ff fc c5 	call  2002e1c <sparc_enable_interrupts>        
 2003b0c:	90 10 00 1b 	mov  %i3, %o0                                  
 2003b10:	81 c7 e0 08 	ret                                            
 2003b14:	81 e8 00 00 	restore                                        
  } else {                                                            
    rtems_interrupt_enable(level);                                    
 2003b18:	7f ff fc c1 	call  2002e1c <sparc_enable_interrupts>        <== NOT EXECUTED
 2003b1c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
    sc = disk_lock();                                                 
 2003b20:	7f ff fe a5 	call  20035b4 <disk_lock>                      <== NOT EXECUTED
 2003b24:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (sc == RTEMS_SUCCESSFUL) {                                     
 2003b28:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2003b2c:	12 bf ff f9 	bne  2003b10 <rtems_disk_obtain+0x3c>          <== NOT EXECUTED
 2003b30:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      dd = get_disk_entry(dev, false);                                
 2003b34:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2003b38:	7f ff fe 64 	call  20034c8 <get_disk_entry>                 <== NOT EXECUTED
 2003b3c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
      disk_unlock();                                                  
 2003b40:	7f ff fe ac 	call  20035f0 <disk_unlock>                    <== NOT EXECUTED
 2003b44:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return dd;                                                          
}                                                                     
 2003b48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003b4c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02011074 <rtems_event_system_receive>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) {
 2011074:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc;                                               
                                                                      
  if ( event_out != NULL ) {                                          
 2011078:	80 a6 e0 00 	cmp  %i3, 0                                    
 201107c:	02 80 00 1e 	be  20110f4 <rtems_event_system_receive+0x80>  <== NEVER TAKEN
 2011080:	82 10 20 09 	mov  9, %g1                                    
    Thread_Control    *executing = _Thread_Executing;                 
 2011084:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
 2011088:	fa 00 63 20 	ld  [ %g1 + 0x320 ], %i5	! 2021f20 <_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 ) ) {                        
 201108c:	80 a6 20 00 	cmp  %i0, 0                                    
 2011090:	02 80 00 16 	be  20110e8 <rtems_event_system_receive+0x74>  <== NEVER TAKEN
 2011094:	da 07 61 58 	ld  [ %i5 + 0x158 ], %o5                       
   *                                                                  
   * 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;                  
 2011098:	03 00 80 86 	sethi  %hi(0x2021800), %g1                     
 201109c:	c4 00 61 f0 	ld  [ %g1 + 0x1f0 ], %g2	! 20219f0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 20110a0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 20110a4:	c4 20 61 f0 	st  %g2, [ %g1 + 0x1f0 ]                       
      _Thread_Disable_dispatch();                                     
      _Event_Seize(                                                   
 20110a8:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
 20110ac:	82 10 63 10 	or  %g1, 0x310, %g1	! 2022310 <_System_event_Sync_state>
 20110b0:	90 10 00 18 	mov  %i0, %o0                                  
 20110b4:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 20110b8:	92 10 00 19 	mov  %i1, %o1                                  
 20110bc:	03 00 01 00 	sethi  %hi(0x40000), %g1                       
 20110c0:	94 10 00 1a 	mov  %i2, %o2                                  
 20110c4:	96 10 00 1b 	mov  %i3, %o3                                  
 20110c8:	98 10 00 1d 	mov  %i5, %o4                                  
 20110cc:	9a 03 60 04 	add  %o5, 4, %o5                               
 20110d0:	7f ff dd 1c 	call  2008540 <_Event_Seize>                   
 20110d4:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
        executing,                                                    
        event,                                                        
        &_System_event_Sync_state,                                    
        STATES_WAITING_FOR_SYSTEM_EVENT                               
      );                                                              
      _Thread_Enable_dispatch();                                      
 20110d8:	7f ff e8 9d 	call  200b34c <_Thread_Enable_dispatch>        
 20110dc:	01 00 00 00 	nop                                            
                                                                      
      sc = executing->Wait.return_code;                               
 20110e0:	10 80 00 05 	b  20110f4 <rtems_event_system_receive+0x80>   
 20110e4:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
    } else {                                                          
      *event_out = event->pending_events;                             
 20110e8:	c2 03 60 04 	ld  [ %o5 + 4 ], %g1                           <== NOT EXECUTED
 20110ec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               <== NOT EXECUTED
      sc = RTEMS_SUCCESSFUL;                                          
 20110f0:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
  } else {                                                            
    sc = RTEMS_INVALID_ADDRESS;                                       
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 20110f4:	81 c7 e0 08 	ret                                            
 20110f8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200789c <rtems_event_system_send>: rtems_status_code rtems_event_system_send( rtems_id id, rtems_event_set event_in ) {
 200789c:	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 );                              
 20078a0:	90 10 00 18 	mov  %i0, %o0                                  
 20078a4:	40 00 09 f7 	call  200a080 <_Thread_Get>                    
 20078a8:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 20078ac:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
 20078b0:	80 a0 a0 00 	cmp  %g2, 0                                    
 20078b4:	12 80 00 0d 	bne  20078e8 <rtems_event_system_send+0x4c>    <== NEVER TAKEN
 20078b8:	92 10 00 19 	mov  %i1, %o1                                  
    case OBJECTS_LOCAL:                                               
      api = thread->API_Extensions[ THREAD_API_RTEMS ];               
      _Event_Surrender(                                               
 20078bc:	d4 02 21 58 	ld  [ %o0 + 0x158 ], %o2                       
 20078c0:	94 02 a0 04 	add  %o2, 4, %o2                               
 20078c4:	19 00 01 00 	sethi  %hi(0x40000), %o4                       
 20078c8:	17 00 80 77 	sethi  %hi(0x201dc00), %o3                     
 20078cc:	96 12 e2 f0 	or  %o3, 0x2f0, %o3	! 201def0 <_System_event_Sync_state>
 20078d0:	7f ff fe 64 	call  2007260 <_Event_Surrender>               
 20078d4:	b0 10 20 00 	clr  %i0                                       
        event_in,                                                     
        &api->System_event,                                           
        &_System_event_Sync_state,                                    
        STATES_WAITING_FOR_SYSTEM_EVENT                               
      );                                                              
      _Thread_Enable_dispatch();                                      
 20078d8:	40 00 09 de 	call  200a050 <_Thread_Enable_dispatch>        
 20078dc:	01 00 00 00 	nop                                            
      sc = RTEMS_SUCCESSFUL;                                          
      break;                                                          
 20078e0:	81 c7 e0 08 	ret                                            
 20078e4:	81 e8 00 00 	restore                                        
      sc = RTEMS_INVALID_ID;                                          
      break;                                                          
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 20078e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20078ec:	91 e8 20 04 	restore  %g0, 4, %o0                           <== NOT EXECUTED
                                                                      

02007434 <rtems_fdisk_abort.constprop.0>: * * @param format The format string. See printf for details. * @param ... The arguments for the format text. */ static void rtems_fdisk_abort (const char *format, ...)
 2007434:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
 2007438:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
 200743c:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
 2007440:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
 2007444:	3b 00 80 d7 	sethi  %hi(0x2035c00), %i5                     <== NOT EXECUTED
 2007448:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1	! 2035f00 <_impure_ptr><== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_abort (const char *format, ...)                           
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
 200744c:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
 2007450:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
 2007454:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
 2007458:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
 200745c:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
 2007460:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 2007464:	40 00 67 be 	call  202135c <fputs>                          <== NOT EXECUTED
 2007468:	90 12 23 a0 	or  %o0, 0x3a0, %o0	! 2030ba0 <__FUNCTION__.7127+0x4c8><== NOT EXECUTED
  vfprintf (stderr, format, args);                                    
 200746c:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2007470:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 2007474:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
 2007478:	40 00 67 b9 	call  202135c <fputs>                          <== NOT EXECUTED
 200747c:	90 12 23 b0 	or  %o0, 0x3b0, %o0                            <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
 2007480:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2007484:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
 2007488:	40 00 67 81 	call  202128c <fputc>                          <== NOT EXECUTED
 200748c:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
  fflush (stderr);                                                    
 2007490:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2007494:	40 00 66 66 	call  2020e2c <fflush>                         <== NOT EXECUTED
 2007498:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
  va_end (args);                                                      
  exit (1);                                                           
 200749c:	40 00 65 64 	call  2020a2c <exit>                           <== NOT EXECUTED
 20074a0:	90 10 20 01 	mov  1, %o0                                    <== NOT EXECUTED
                                                                      

02005b70 <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) {
 2005b70:	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)                                                     
 2005b74:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        
 2005b78:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 2005b7c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2005b80:	1a 80 00 72 	bcc  2005d48 <rtems_fdisk_compact+0x1d8>       
 2005b84:	ba 10 00 18 	mov  %i0, %i5                                  
    fd->starvations++;                                                
 2005b88:	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");                   
 2005b8c:	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++;                                                
 2005b90:	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");                   
 2005b94:	13 00 80 c3 	sethi  %hi(0x2030c00), %o1                     
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
    fd->starvations++;                                                
 2005b98:	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");                   
 2005b9c:	7f ff fc ac 	call  2004e4c <rtems_fdisk_printf>             
 2005ba0:	92 12 63 78 	or  %o1, 0x378, %o1                            
#endif                                                                
                                                                      
    ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);             
 2005ba4:	7f ff fb d6 	call  2004afc <rtems_fdisk_segment_queue_pop_head>
 2005ba8:	90 06 20 40 	add  %i0, 0x40, %o0                            
    if (!ssc)                                                         
 2005bac:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2005bb0:	12 80 00 07 	bne  2005bcc <rtems_fdisk_compact+0x5c>        <== ALWAYS TAKEN
 2005bb4:	01 00 00 00 	nop                                            
      ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);      
 2005bb8:	7f ff fb d1 	call  2004afc <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
 2005bbc:	90 06 20 34 	add  %i0, 0x34, %o0                            <== NOT EXECUTED
                                                                      
    if (ssc)                                                          
 2005bc0:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
 2005bc4:	02 80 00 12 	be  2005c0c <rtems_fdisk_compact+0x9c>         <== NOT EXECUTED
 2005bc8:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
    {                                                                 
      dsc = rtems_fdisk_seg_most_available (&fd->available);          
 2005bcc:	7f ff fc 6e 	call  2004d84 <rtems_fdisk_seg_most_available> 
 2005bd0:	90 07 60 34 	add  %i5, 0x34, %o0                            
      if (dsc)                                                        
 2005bd4:	94 92 20 00 	orcc  %o0, 0, %o2                              
 2005bd8:	02 80 00 0a 	be  2005c00 <rtems_fdisk_compact+0x90>         <== NEVER TAKEN
 2005bdc:	92 10 00 1c 	mov  %i4, %o1                                  
      {                                                               
        ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);     
 2005be0:	90 10 00 1d 	mov  %i5, %o0                                  
 2005be4:	7f ff ff 02 	call  20057ec <rtems_fdisk_recycle_segment>    
 2005be8:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (ret)                                                      
 2005bec:	80 a2 20 00 	cmp  %o0, 0                                    
 2005bf0:	02 80 00 57 	be  2005d4c <rtems_fdisk_compact+0x1dc>        <== ALWAYS TAKEN
 2005bf4:	21 00 80 c3 	sethi  %hi(0x2030c00), %l0                     
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2005bf8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2005bfc:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
        if (ret)                                                      
          return ret;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_fdisk_error ("compacting: starvation");                 
 2005c00:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 2005c04:	10 80 00 03 	b  2005c10 <rtems_fdisk_compact+0xa0>          <== NOT EXECUTED
 2005c08:	90 12 23 90 	or  %o0, 0x390, %o0	! 2030f90 <__FUNCTION__.7127+0x8b8><== NOT EXECUTED
        return EIO;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      rtems_fdisk_error ("compacting: nothing to recycle");           
 2005c0c:	90 12 23 a8 	or  %o0, 0x3a8, %o0                            <== NOT EXECUTED
 2005c10:	7f ff fc cf 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005c14:	01 00 00 00 	nop                                            <== NOT EXECUTED
      return EIO;                                                     
 2005c18:	10 80 00 61 	b  2005d9c <rtems_fdisk_compact+0x22c>         <== NOT EXECUTED
 2005c1c:	90 10 20 05 	mov  5, %o0	! 5 <PROM_START+0x5>               <== NOT EXECUTED
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
 2005c20:	7f ff fc 8b 	call  2004e4c <rtems_fdisk_printf>             
 2005c24:	90 10 00 1d 	mov  %i5, %o0                                  
#endif                                                                
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
 2005c28:	7f ff fc 57 	call  2004d84 <rtems_fdisk_seg_most_available> 
 2005c2c:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    if (dsc == 0)                                                     
 2005c30:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2005c34:	12 80 00 05 	bne  2005c48 <rtems_fdisk_compact+0xd8>        <== ALWAYS TAKEN
 2005c38:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_fdisk_error ("compacting: no available segments to compact too");
 2005c3c:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 2005c40:	10 bf ff f4 	b  2005c10 <rtems_fdisk_compact+0xa0>          <== NOT EXECUTED
 2005c44:	90 12 23 d8 	or  %o0, 0x3d8, %o0	! 2030fd8 <__FUNCTION__.7127+0x900><== NOT EXECUTED
      return EIO;                                                     
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
 2005c48:	7f ff fc 47 	call  2004d64 <rtems_fdisk_seg_pages_available>
 2005c4c:	01 00 00 00 	nop                                            
    segments = 0;                                                     
    pages = 0;                                                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
 2005c50:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
 2005c54:	d6 06 e0 0c 	ld  [ %i3 + 0xc ], %o3                         
    {                                                                 
      rtems_fdisk_error ("compacting: no available segments to compact too");
      return EIO;                                                     
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
 2005c58:	f8 07 60 40 	ld  [ %i5 + 0x40 ], %i4                        
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
 2005c5c:	b0 10 00 08 	mov  %o0, %i0                                  
    segments = 0;                                                     
    pages = 0;                                                        
 2005c60:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",         
 2005c64:	90 10 00 1d 	mov  %i5, %o0                                  
 2005c68:	7f ff fc 79 	call  2004e4c <rtems_fdisk_printf>             
 2005c6c:	92 10 00 11 	mov  %l1, %o1                                  
 2005c70:	d8 07 bf fc 	ld  [ %fp + -4 ], %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 &&                                                     
 2005c74:	10 80 00 04 	b  2005c84 <rtems_fdisk_compact+0x114>         
 2005c78:	9a 10 20 00 	clr  %o5                                       
           ((pages + ssc->pages_active) < dst_pages) &&               
           ((compacted_segs + segments) < fd->compact_segs))          
    {                                                                 
      pages += ssc->pages_active;                                     
      segments++;                                                     
 2005c7c:	9a 03 60 01 	inc  %o5                                       
                                                                      
    while (ssc &&                                                     
           ((pages + ssc->pages_active) < dst_pages) &&               
           ((compacted_segs + segments) < fd->compact_segs))          
    {                                                                 
      pages += ssc->pages_active;                                     
 2005c80:	98 10 00 01 	mov  %g1, %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 &&                                                     
 2005c84:	80 a7 20 00 	cmp  %i4, 0                                    
 2005c88:	32 80 00 09 	bne,a   2005cac <rtems_fdisk_compact+0x13c>    
 2005c8c:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
 2005c90:	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");                 
 2005c94:	90 10 00 1d 	mov  %i5, %o0                                  
 2005c98:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2005c9c:	7f ff fc 6c 	call  2004e4c <rtems_fdisk_printf>             
 2005ca0:	92 12 60 30 	or  %o1, 0x30, %o1	! 2031030 <__FUNCTION__.7127+0x958>
    }                                                                 
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
 2005ca4:	10 80 00 3e 	b  2005d9c <rtems_fdisk_compact+0x22c>         
 2005ca8:	90 10 20 00 	clr  %o0                                       
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
           ((pages + ssc->pages_active) < dst_pages) &&               
 2005cac:	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 &&                                                     
 2005cb0:	80 a0 40 18 	cmp  %g1, %i0                                  
 2005cb4:	1a 80 00 34 	bcc  2005d84 <rtems_fdisk_compact+0x214>       
 2005cb8:	86 03 40 1a 	add  %o5, %i2, %g3                             
           ((pages + ssc->pages_active) < dst_pages) &&               
 2005cbc:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
 2005cc0:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2005cc4:	2a bf ff ee 	bcs,a   2005c7c <rtems_fdisk_compact+0x10c>    <== ALWAYS TAKEN
 2005cc8:	f8 07 00 00 	ld  [ %i4 ], %i4                               
 2005ccc:	10 80 00 2f 	b  2005d88 <rtems_fdisk_compact+0x218>         <== NOT EXECUTED
 2005cd0:	d8 27 bf fc 	st  %o4, [ %fp + -4 ]                          <== NOT EXECUTED
     * 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))   
 2005cd4:	80 a6 a0 01 	cmp  %i2, 1                                    
 2005cd8:	22 bf ff f0 	be,a   2005c98 <rtems_fdisk_compact+0x128>     
 2005cdc:	90 10 00 1d 	mov  %i5, %o0                                  
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
 2005ce0:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           
 2005ce4:	d6 07 20 0c 	ld  [ %i4 + 0xc ], %o3                         
 2005ce8:	92 10 00 12 	mov  %l2, %o1                                  
 2005cec:	7f ff fc 58 	call  2004e4c <rtems_fdisk_printf>             
 2005cf0:	90 10 00 1d 	mov  %i5, %o0                                  
                        ssc->device, ssc->segment,                    
                        pages, segments);                             
#endif                                                                
                                                                      
    rtems_fdisk_segment_queue_remove (&fd->available, dsc);           
 2005cf4:	90 10 00 19 	mov  %i1, %o0                                  
 2005cf8:	7f ff fb a3 	call  2004b84 <rtems_fdisk_segment_queue_remove>
 2005cfc:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
    /*                                                                
     * We now copy the pages to the new segment.                      
     */                                                               
                                                                      
    while (pages)                                                     
 2005d00:	10 80 00 0e 	b  2005d38 <rtems_fdisk_compact+0x1c8>         
 2005d04:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    {                                                                 
      ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);           
 2005d08:	7f ff fb 7d 	call  2004afc <rtems_fdisk_segment_queue_pop_head>
 2005d0c:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
      if (ssc)                                                        
 2005d10:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2005d14:	02 80 00 09 	be  2005d38 <rtems_fdisk_compact+0x1c8>        <== NEVER TAKEN
 2005d18:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
      {                                                               
        ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);     
 2005d1c:	90 10 00 1d 	mov  %i5, %o0                                  
 2005d20:	94 10 00 1b 	mov  %i3, %o2                                  
 2005d24:	7f ff fe b2 	call  20057ec <rtems_fdisk_recycle_segment>    
 2005d28:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (ret)                                                      
 2005d2c:	80 a2 20 00 	cmp  %o0, 0                                    
 2005d30:	12 80 00 1b 	bne  2005d9c <rtems_fdisk_compact+0x22c>       <== NEVER TAKEN
 2005d34:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
    /*                                                                
     * We now copy the pages to the new segment.                      
     */                                                               
                                                                      
    while (pages)                                                     
 2005d38:	80 a0 60 00 	cmp  %g1, 0                                    
 2005d3c:	22 80 00 0d 	be,a   2005d70 <rtems_fdisk_compact+0x200>     
 2005d40:	c2 07 60 40 	ld  [ %i5 + 0x40 ], %g1                        
 2005d44:	30 bf ff f1 	b,a   2005d08 <rtems_fdisk_compact+0x198>      
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
 2005d48:	21 00 80 c3 	sethi  %hi(0x2030c00), %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",         
 2005d4c:	23 00 80 c4 	sethi  %hi(0x2031000), %l1                     
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
 2005d50:	25 00 80 c4 	sethi  %hi(0x2031000), %l2                     
     * compaction or less delay when compacting but it may mean the disk
     * will fill.                                                     
     */                                                               
                                                                      
    while (ssc &&                                                     
           ((pages + ssc->pages_active) < dst_pages) &&               
 2005d54:	b4 10 20 00 	clr  %i2                                       
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
 2005d58:	a0 14 23 c8 	or  %l0, 0x3c8, %l0                            
#endif                                                                
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
 2005d5c:	b2 07 60 34 	add  %i5, 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",         
 2005d60:	a2 14 60 10 	or  %l1, 0x10, %l1                             
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
 2005d64:	a4 14 a0 48 	or  %l2, 0x48, %l2                             
     * We now copy the pages to the new segment.                      
     */                                                               
                                                                      
    while (pages)                                                     
    {                                                                 
      ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);           
 2005d68:	a6 07 60 40 	add  %i5, 0x40, %l3                            
      rtems_fdisk_error ("compacting: nothing to recycle");           
      return EIO;                                                     
    }                                                                 
  }                                                                   
                                                                      
  while (fd->used.head)                                               
 2005d6c:	c2 07 60 40 	ld  [ %i5 + 0x40 ], %g1                        
 2005d70:	80 a0 60 00 	cmp  %g1, 0                                    
 2005d74:	12 bf ff ab 	bne  2005c20 <rtems_fdisk_compact+0xb0>        
 2005d78:	92 10 00 10 	mov  %l0, %o1                                  
    }                                                                 
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
 2005d7c:	10 80 00 08 	b  2005d9c <rtems_fdisk_compact+0x22c>         
 2005d80:	90 10 20 00 	clr  %o0                                       
 2005d84:	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))   
 2005d88:	80 a3 20 00 	cmp  %o4, 0                                    
 2005d8c:	32 bf ff d2 	bne,a   2005cd4 <rtems_fdisk_compact+0x164>    
 2005d90:	b4 06 80 0d 	add  %i2, %o5, %i2                             
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_printf (fd, " nothing to compact");                 
 2005d94:	10 bf ff c1 	b  2005c98 <rtems_fdisk_compact+0x128>         
 2005d98:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2005d9c:	b0 10 00 08 	mov  %o0, %i0                                  
 2005da0:	81 c7 e0 08 	ret                                            
 2005da4:	81 e8 00 00 	restore                                        
                                                                      

02004fc0 <rtems_fdisk_erase_segment>: /** * Erase the segment. */ static int rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc) {
 2004fc0:	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;                                                
 2004fc4:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
  segment = sc->segment;                                              
 2004fc8:	d4 06 60 0c 	ld  [ %i1 + 0xc ], %o2                         
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;            
 2004fcc:	85 2a 60 04 	sll  %o1, 4, %g2                               
 2004fd0:	83 2a 60 02 	sll  %o1, 2, %g1                               
 2004fd4:	82 20 80 01 	sub  %g2, %g1, %g1                             
 2004fd8:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
 2004fdc:	89 2a a0 06 	sll  %o2, 6, %g4                               
 2004fe0:	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;                    
 2004fe4:	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;            
 2004fe8:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
  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);                             
 2004fec:	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;            
 2004ff0:	85 2a a0 04 	sll  %o2, 4, %g2                               
 2004ff4:	84 21 00 02 	sub  %g4, %g2, %g2                             
 2004ff8:	84 00 40 02 	add  %g1, %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);                             
 2004ffc:	c2 00 e0 10 	ld  [ %g3 + 0x10 ], %g1                        
 2005000:	9f c0 40 00 	call  %g1                                      
 2005004:	d0 00 a0 04 	ld  [ %g2 + 4 ], %o0                           
  if (ret)                                                            
 2005008:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 200500c:	22 80 00 16 	be,a   2005064 <rtems_fdisk_erase_segment+0xa4><== ALWAYS TAKEN
 2005010:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        
  {                                                                   
    rtems_fdisk_error (" erase-segment:%02d-%03d: "      \            
 2005014:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
 2005018:	40 00 78 47 	call  2023134 <strerror>                       <== NOT EXECUTED
 200501c:	f8 06 60 0c 	ld  [ %i1 + 0xc ], %i4                         <== NOT EXECUTED
 2005020:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 2005024:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2005028:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 200502c:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
 2005030:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 2005034:	7f ff ff c6 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005038:	90 12 23 d0 	or  %o0, 0x3d0, %o0	! 2030bd0 <__FUNCTION__.7127+0x4f8><== NOT EXECUTED
                       "segment erase failed: %s (%d)",               
                       sc->device, sc->segment, strerror (ret), ret); 
    sc->failed = true;                                                
 200503c:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
    if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))         
 2005040:	b0 06 20 58 	add  %i0, 0x58, %i0                            <== 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;                                                
 2005044:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
    if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))         
 2005048:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200504c:	7f ff ff 09 	call  2004c70 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
 2005050:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2005054:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2005058:	12 80 00 18 	bne  20050b8 <rtems_fdisk_erase_segment+0xf8>  <== NOT EXECUTED
 200505c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2005060:	30 80 00 14 	b,a   20050b0 <rtems_fdisk_erase_segment+0xf0> <== NOT EXECUTED
      rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);          
    return ret;                                                       
  }                                                                   
                                                                      
  fd->erased_blocks += sc->pages;                                     
 2005064:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
 2005068:	d2 06 60 18 	ld  [ %i1 + 0x18 ], %o1                        
    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;                                     
 200506c:	82 00 80 01 	add  %g2, %g1, %g1                             
 2005070:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  sc->erased++;                                                       
 2005074:	c2 06 60 2c 	ld  [ %i1 + 0x2c ], %g1                        
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
 2005078:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
      rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);          
    return ret;                                                       
  }                                                                   
                                                                      
  fd->erased_blocks += sc->pages;                                     
  sc->erased++;                                                       
 200507c:	82 00 60 01 	inc  %g1                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
 2005080:	f8 06 60 10 	ld  [ %i1 + 0x10 ], %i4                        
 2005084:	7f ff f5 44 	call  2002594 <.umul>                          
 2005088:	c2 26 60 2c 	st  %g1, [ %i1 + 0x2c ]                        
 200508c:	92 10 20 ff 	mov  0xff, %o1                                 
 2005090:	94 10 00 08 	mov  %o0, %o2                                  
 2005094:	40 00 73 3e 	call  2021d8c <memset>                         
 2005098:	90 10 00 1c 	mov  %i4, %o0                                  
  /*                                                                  
   * Push to the tail of the available queue. It is a very            
   * simple type of wear reduction. Every other available             
   * segment will now get a go.                                       
   */                                                                 
  rtems_fdisk_segment_queue_push_tail (&fd->available, sc);           
 200509c:	90 06 20 34 	add  %i0, 0x34, %o0                            
  fd->erased_blocks += sc->pages;                                     
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
                                                                      
  sc->pages_active = 0;                                               
 20050a0:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  sc->pages_used   = 0;                                               
 20050a4:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
  sc->pages_bad    = 0;                                               
 20050a8:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
                                                                      
  sc->failed = false;                                                 
 20050ac:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
  /*                                                                  
   * Push to the tail of the available queue. It is a very            
   * simple type of wear reduction. Every other available             
   * segment will now get a go.                                       
   */                                                                 
  rtems_fdisk_segment_queue_push_tail (&fd->available, sc);           
 20050b0:	7f ff fe a3 	call  2004b3c <rtems_fdisk_segment_queue_push_tail>
 20050b4:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  return 0;                                                           
}                                                                     
 20050b8:	81 c7 e0 08 	ret                                            
 20050bc:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

02004f4c <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, ...) {
 2004f4c:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
 2004f50:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
 2004f54:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
 2004f58:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
 2004f5c:	3b 00 80 d7 	sethi  %hi(0x2035c00), %i5                     <== NOT EXECUTED
 2004f60:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1	! 2035f00 <_impure_ptr><== NOT EXECUTED
static int                                                            
rtems_fdisk_error (const char *format, ...)                           
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
 2004f64:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
 2004f68:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
 2004f6c:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
 2004f70:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
 2004f74:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
 2004f78:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 2004f7c:	40 00 70 f8 	call  202135c <fputs>                          <== NOT EXECUTED
 2004f80:	90 12 23 90 	or  %o0, 0x390, %o0	! 2030b90 <__FUNCTION__.7127+0x4b8><== NOT EXECUTED
  ret =  vfprintf (stderr, format, args);                             
 2004f84:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004f88:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
 2004f8c:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
 2004f90:	40 00 93 41 	call  2029c94 <vfprintf>                       <== NOT EXECUTED
 2004f94:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
 2004f98:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:error:");                                   
  ret =  vfprintf (stderr, format, args);                             
 2004f9c:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
 2004fa0:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
 2004fa4:	40 00 70 ba 	call  202128c <fputc>                          <== NOT EXECUTED
 2004fa8:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
  fflush (stderr);                                                    
 2004fac:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004fb0:	40 00 6f 9f 	call  2020e2c <fflush>                         <== NOT EXECUTED
 2004fb4:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
  va_end (args);                                                      
  return ret;                                                         
}                                                                     
 2004fb8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004fbc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02004dcc <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, ...) {
 2004dcc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
 2004dd0:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
 2004dd4:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
 2004dd8:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
 2004ddc:	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)                                            
 2004de0:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        
 2004de4:	80 a0 60 01 	cmp  %g1, 1                                    
 2004de8:	08 80 00 17 	bleu  2004e44 <rtems_fdisk_info+0x78>          <== ALWAYS TAKEN
 2004dec:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
 2004df0:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            <== NOT EXECUTED
    fprintf (stdout, "fdisk:");                                       
 2004df4:	3b 00 80 d7 	sethi  %hi(0x2035c00), %i5                     <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
 2004df8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
    fprintf (stdout, "fdisk:");                                       
 2004dfc:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004e00:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 2004e04:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
 2004e08:	40 00 71 55 	call  202135c <fputs>                          <== NOT EXECUTED
 2004e0c:	90 12 23 78 	or  %o0, 0x378, %o0                            <== NOT EXECUTED
    ret =  vfprintf (stdout, format, args);                           
 2004e10:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004e14:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
 2004e18:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
 2004e1c:	40 00 93 9e 	call  2029c94 <vfprintf>                       <== NOT EXECUTED
 2004e20:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
 2004e24:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:");                                       
    ret =  vfprintf (stdout, format, args);                           
 2004e28:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
 2004e2c:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
 2004e30:	40 00 71 17 	call  202128c <fputc>                          <== NOT EXECUTED
 2004e34:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
    fflush (stdout);                                                  
 2004e38:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004e3c:	40 00 6f fc 	call  2020e2c <fflush>                         <== NOT EXECUTED
 2004e40:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    va_end (args);                                                    
  }                                                                   
  return ret;                                                         
}                                                                     
 2004e44:	81 c7 e0 08 	ret                                            
 2004e48:	81 e8 00 00 	restore                                        
                                                                      

02006f38 <rtems_fdisk_initialize>: */ rtems_device_driver rtems_fdisk_initialize (rtems_device_major_number major, rtems_device_minor_number minor, void* arg __attribute__((unused))) {
 2006f38:	9d e3 bf 68 	save  %sp, -152, %sp                           
  const rtems_flashdisk_config* c = rtems_flashdisk_configuration;    
  rtems_flashdisk*              fd;                                   
  rtems_status_code             sc;                                   
                                                                      
  sc = rtems_disk_io_initialize ();                                   
 2006f3c:	7f ff f6 8b 	call  2004968 <rtems_disk_io_initialize>       
 2006f40:	a0 10 00 18 	mov  %i0, %l0                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
 2006f44:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2006f48:	12 80 01 39 	bne  200742c <rtems_fdisk_initialize+0x4f4>    <== NEVER TAKEN
 2006f4c:	01 00 00 00 	nop                                            
static rtems_status_code                                              
rtems_fdisk_crc16_gen_factors (uint16_t pattern)                      
{                                                                     
  uint32_t b;                                                         
                                                                      
  rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);        
 2006f50:	40 00 05 b6 	call  2008628 <malloc>                         
 2006f54:	90 10 22 00 	mov  0x200, %o0	! 200 <PROM_START+0x200>       
 2006f58:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     
 2006f5c:	d0 20 60 88 	st  %o0, [ %g1 + 0x88 ]	! 2046488 <rtems_fdisk_crc16_factor>
  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;                        
 2006f60:	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)                                      
 2006f64:	82 10 20 00 	clr  %g1                                       
 2006f68:	80 a2 20 00 	cmp  %o0, 0                                    
 2006f6c:	12 80 00 04 	bne  2006f7c <rtems_fdisk_initialize+0x44>     <== ALWAYS TAKEN
 2006f70:	88 11 20 08 	or  %g4, 8, %g4                                
    /*                                                                
     * One copy buffer of a page size.                                
     */                                                               
    fd->copy_buffer = malloc (c->block_size);                         
    if (!fd->copy_buffer)                                             
      return RTEMS_NO_MEMORY;                                         
 2006f74:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2006f78:	91 e8 20 1a 	restore  %g0, 0x1a, %o0                        <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
 2006f7c:	84 10 00 01 	mov  %g1, %g2                                  
 2006f80:	10 80 00 06 	b  2006f98 <rtems_fdisk_initialize+0x60>       
 2006f84:	86 10 20 09 	mov  9, %g3                                    
 2006f88:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
 2006f8c:	02 80 00 03 	be  2006f98 <rtems_fdisk_initialize+0x60>      
 2006f90:	85 30 a0 11 	srl  %g2, 0x11, %g2                            
 2006f94:	84 18 80 04 	xor  %g2, %g4, %g2                             
                                                                      
  for (b = 0; b < 256; b++)                                           
  {                                                                   
    uint32_t i;                                                       
    uint16_t v = b;                                                   
    for (i = 8; i--;)                                                 
 2006f98:	86 80 ff ff 	addcc  %g3, -1, %g3                            
 2006f9c:	12 bf ff fb 	bne  2006f88 <rtems_fdisk_initialize+0x50>     
 2006fa0:	80 88 a0 01 	btst  1, %g2                                   
 * @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,              
 2006fa4:	87 28 60 01 	sll  %g1, 1, %g3                               
                                                                      
  rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);        
  if (!rtems_fdisk_crc16_factor)                                      
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (b = 0; b < 256; b++)                                           
 2006fa8:	82 00 60 01 	inc  %g1                                       
 2006fac:	80 a0 61 00 	cmp  %g1, 0x100                                
 2006fb0:	12 bf ff f3 	bne  2006f7c <rtems_fdisk_initialize+0x44>     
 2006fb4:	c4 32 00 03 	sth  %g2, [ %o0 + %g3 ]                        
                                                                      
  sc = rtems_fdisk_crc16_gen_factors (0x8408);                        
  if (sc != RTEMS_SUCCESSFUL)                                         
      return sc;                                                      
                                                                      
  rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,      
 2006fb8:	10 80 01 0f 	b  20073f4 <rtems_fdisk_initialize+0x4bc>      
 2006fbc:	2f 00 80 d7 	sethi  %hi(0x2035c00), %l7                     
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
    int      ret;                                                     
                                                                      
    fd = &rtems_flashdisks[minor];                                    
 2006fc0:	c2 05 60 80 	ld  [ %l5 + 0x80 ], %g1                        
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
 2006fc4:	f2 2f bf f9 	stb  %i1, [ %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";           
 2006fc8:	05 0b d9 19 	sethi  %hi(0x2f646400), %g2                    
 2006fcc:	07 0b d9 99 	sethi  %hi(0x2f666400), %g3                    
 2006fd0:	84 10 a1 76 	or  %g2, 0x176, %g2                            
 2006fd4:	86 10 e0 64 	or  %g3, 0x64, %g3                             
 2006fd8:	c4 3f bf f0 	std  %g2, [ %fp + -16 ]                        
    dev_t    dev = rtems_filesystem_make_dev_t (major, minor);        
    uint32_t device;                                                  
    uint32_t blocks = 0;                                              
    int      ret;                                                     
                                                                      
    fd = &rtems_flashdisks[minor];                                    
 2006fdc:	b6 00 40 12 	add  %g1, %l2, %i3                             
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
 2006fe0:	e0 20 40 12 	st  %l0, [ %g1 + %l2 ]                         
    fd->minor              = minor;                                   
    fd->flags              = c->flags;                                
 2006fe4:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
    fd->compact_segs       = c->compact_segs;                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
    fd->block_size         = c->block_size;                           
 2006fe8:	e6 06 80 00 	ld  [ %i2 ], %l3                               
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
    fd->flags              = c->flags;                                
 2006fec:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
    fd->compact_segs       = c->compact_segs;                         
 2006ff0:	c2 06 a0 14 	ld  [ %i2 + 0x14 ], %g1                        
    fd = &rtems_flashdisks[minor];                                    
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
 2006ff4:	f2 26 e0 04 	st  %i1, [ %i3 + 4 ]                           
    fd->flags              = c->flags;                                
    fd->compact_segs       = c->compact_segs;                         
 2006ff8:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
 2006ffc:	c2 06 a0 18 	ld  [ %i2 + 0x18 ], %g1                        
    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++)              
 2007000:	da 06 a0 04 	ld  [ %i2 + 4 ], %o5                           
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
    fd->flags              = c->flags;                                
    fd->compact_segs       = c->compact_segs;                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
 2007004:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        
    fd->block_size         = c->block_size;                           
    fd->unavail_blocks     = c->unavail_blocks;                       
 2007008:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
    fd->major              = major;                                   
    fd->minor              = minor;                                   
    fd->flags              = c->flags;                                
    fd->compact_segs       = c->compact_segs;                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
    fd->block_size         = c->block_size;                           
 200700c:	e6 26 e0 14 	st  %l3, [ %i3 + 0x14 ]                        
    fd->unavail_blocks     = c->unavail_blocks;                       
 2007010:	c2 26 e0 20 	st  %g1, [ %i3 + 0x20 ]                        
    fd->info_level         = c->info_level;                           
 2007014:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
                                                                      
    for (device = 0; device < c->device_count; device++)              
 2007018:	a8 10 20 00 	clr  %l4                                       
    fd->flags              = c->flags;                                
    fd->compact_segs       = c->compact_segs;                         
    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;                           
 200701c:	c2 26 e0 6c 	st  %g1, [ %i3 + 0x6c ]                        
  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;                                              
 2007020:	a2 10 20 00 	clr  %l1                                       
    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++)              
 2007024:	10 80 00 25 	b  20070b8 <rtems_fdisk_initialize+0x180>      
 2007028:	b0 10 20 00 	clr  %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++)                             
 200702c:	ba 10 20 00 	clr  %i5                                       
    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++)              
      blocks += rtems_fdisk_blocks_in_device (&c->devices[device],    
 2007030:	b8 00 40 14 	add  %g1, %l4, %i4                             
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++)                             
 2007034:	d8 00 40 14 	ld  [ %g1 + %l4 ], %o4                         
 2007038:	86 10 20 00 	clr  %g3                                       
 */                                                                   
static uint32_t                                                       
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,      
                              uint32_t                       page_size)
{                                                                     
  uint32_t count = 0;                                                 
 200703c:	10 80 00 19 	b  20070a0 <rtems_fdisk_initialize+0x168>      
 2007040:	84 10 20 00 	clr  %g2                                       
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
 2007044:	92 10 00 13 	mov  %l3, %o1                                  
{                                                                     
  uint32_t count = 0;                                                 
  uint32_t s;                                                         
  for (s = 0; s < dd->segment_count; s++)                             
  {                                                                   
    const rtems_fdisk_segment_desc* sd = &dd->segments[s];            
 2007048:	9e 01 00 1d 	add  %g4, %i5, %o7                             
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
 200704c:	d0 03 e0 08 	ld  [ %o7 + 8 ], %o0                           
 2007050:	c4 3f bf e0 	std  %g2, [ %fp + -32 ]                        
 2007054:	d8 3f bf d0 	std  %o4, [ %fp + -48 ]                        
 2007058:	7f ff ed 89 	call  200267c <.udiv>                          
 200705c:	c8 27 bf dc 	st  %g4, [ %fp + -36 ]                         
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;                               
 2007060:	94 02 3f ff 	add  %o0, -1, %o2                              
 2007064:	92 10 00 13 	mov  %l3, %o1                                  
 2007068:	d4 27 bf d8 	st  %o2, [ %fp + -40 ]                         
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);            
 200706c:	91 2a 20 03 	sll  %o0, 3, %o0                               
  return ((bytes - 1) / page_size) + 1;                               
 2007070:	7f ff ed 83 	call  200267c <.udiv>                          
 2007074:	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;      
 2007078:	c8 07 bf dc 	ld  [ %fp + -36 ], %g4                         
 200707c:	d4 07 bf d8 	ld  [ %fp + -40 ], %o2                         
 2007080:	d2 11 00 1d 	lduh  [ %g4 + %i5 ], %o1                       
 2007084:	7f ff ed 44 	call  2002594 <.umul>                          
 2007088:	90 22 80 08 	sub  %o2, %o0, %o0                             
  uint32_t count = 0;                                                 
  uint32_t s;                                                         
  for (s = 0; s < dd->segment_count; s++)                             
  {                                                                   
    const rtems_fdisk_segment_desc* sd = &dd->segments[s];            
    count +=                                                          
 200708c:	c4 1f bf e0 	ldd  [ %fp + -32 ], %g2                        
 2007090:	d8 1f bf d0 	ldd  [ %fp + -48 ], %o4                        
 2007094:	84 00 80 08 	add  %g2, %o0, %g2                             
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++)                             
 2007098:	86 00 e0 01 	inc  %g3                                       
 200709c:	ba 07 60 0c 	add  %i5, 0xc, %i5                             
 20070a0:	80 a0 c0 0c 	cmp  %g3, %o4                                  
 20070a4:	32 bf ff e8 	bne,a   2007044 <rtems_fdisk_initialize+0x10c> 
 20070a8:	c8 07 20 04 	ld  [ %i4 + 4 ], %g4                           
    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++)              
      blocks += rtems_fdisk_blocks_in_device (&c->devices[device],    
 20070ac:	a2 04 40 02 	add  %l1, %g2, %l1                             
    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++)              
 20070b0:	b0 06 20 01 	inc  %i0                                       
 20070b4:	a8 05 20 0c 	add  %l4, 0xc, %l4                             
 20070b8:	80 a6 00 0d 	cmp  %i0, %o5                                  
 20070bc:	32 bf ff dc 	bne,a   200702c <rtems_fdisk_initialize+0xf4>  
 20070c0:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
                                              c->block_size);         
                                                                      
    /*                                                                
     * One copy buffer of a page size.                                
     */                                                               
    fd->copy_buffer = malloc (c->block_size);                         
 20070c4:	40 00 05 59 	call  2008628 <malloc>                         
 20070c8:	90 10 00 13 	mov  %l3, %o0                                  
    if (!fd->copy_buffer)                                             
 20070cc:	80 a2 20 00 	cmp  %o0, 0                                    
 20070d0:	02 80 00 bf 	be  20073cc <rtems_fdisk_initialize+0x494>     <== NEVER TAKEN
 20070d4:	d0 26 e0 68 	st  %o0, [ %i3 + 0x68 ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));     
 20070d8:	90 10 00 11 	mov  %l1, %o0                                  
 20070dc:	40 00 02 c2 	call  2007be4 <calloc>                         
 20070e0:	92 10 20 08 	mov  8, %o1                                    
    if (!fd->blocks)                                                  
 20070e4:	80 a2 20 00 	cmp  %o0, 0                                    
 20070e8:	02 80 00 b9 	be  20073cc <rtems_fdisk_initialize+0x494>     <== NEVER TAKEN
 20070ec:	d0 26 e0 18 	st  %o0, [ %i3 + 0x18 ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    fd->block_count = blocks;                                         
 20070f0:	e2 26 e0 1c 	st  %l1, [ %i3 + 0x1c ]                        
                                                                      
    fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
 20070f4:	90 10 00 18 	mov  %i0, %o0                                  
 20070f8:	40 00 02 bb 	call  2007be4 <calloc>                         
 20070fc:	92 10 20 0c 	mov  0xc, %o1                                  
    if (!fd->devices)                                                 
 2007100:	80 a2 20 00 	cmp  %o0, 0                                    
 2007104:	02 80 00 b2 	be  20073cc <rtems_fdisk_initialize+0x494>     <== NEVER TAKEN
 2007108:	d0 26 e0 2c 	st  %o0, [ %i3 + 0x2c ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
 200710c:	07 00 80 c5 	sethi  %hi(0x2031400), %g3                     
 2007110:	d0 00 e3 1c 	ld  [ %g3 + 0x31c ], %o0	! 203171c <__FUNCTION__.7127+0x1044>
 2007114:	92 10 20 01 	mov  1, %o1                                    
 2007118:	94 10 20 54 	mov  0x54, %o2                                 
 200711c:	96 10 20 00 	clr  %o3                                       
 2007120:	40 00 15 a6 	call  200c7b8 <rtems_semaphore_create>         
 2007124:	98 06 e0 64 	add  %i3, 0x64, %o4                            
                                 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
                                 RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
    if (sc != RTEMS_SUCCESSFUL)                                       
 2007128:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200712c:	22 80 00 0d 	be,a   2007160 <rtems_fdisk_initialize+0x228>  <== ALWAYS TAKEN
 2007130:	d6 06 e0 20 	ld  [ %i3 + 0x20 ], %o3                        
    {                                                                 
      rtems_fdisk_error ("disk lock create failed");                  
 2007134:	11 00 80 c5 	sethi  %hi(0x2031400), %o0                     <== NOT EXECUTED
 2007138:	7f ff f7 85 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 200713c:	90 12 22 a0 	or  %o0, 0x2a0, %o0	! 20316a0 <__FUNCTION__.7127+0xfc8><== NOT EXECUTED
      free (fd->copy_buffer);                                         
 2007140:	40 00 03 a9 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007144:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
 2007148:	40 00 03 a7 	call  2007fe4 <free>                           <== NOT EXECUTED
 200714c:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
 2007150:	40 00 03 a5 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007154:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
 2007158:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200715c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      return sc;                                                      
    }                                                                 
                                                                      
    sc = rtems_disk_create_phys(dev, c->block_size,                   
 2007160:	d4 06 80 00 	ld  [ %i2 ], %o2                               
 2007164:	82 07 bf f0 	add  %fp, -16, %g1                             
 2007168:	90 10 00 10 	mov  %l0, %o0                                  
 200716c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 2007170:	92 10 00 19 	mov  %i1, %o1                                  
 2007174:	96 24 40 0b 	sub  %l1, %o3, %o3                             
 2007178:	19 00 80 17 	sethi  %hi(0x2005c00), %o4                     
 200717c:	9a 10 20 00 	clr  %o5                                       
 2007180:	7f ff f5 64 	call  2004710 <rtems_disk_create_phys>         
 2007184:	98 13 21 a8 	or  %o4, 0x1a8, %o4                            
                                blocks - fd->unavail_blocks,          
                                rtems_fdisk_ioctl, NULL, name);       
    if (sc != RTEMS_SUCCESSFUL)                                       
 2007188:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 200718c:	22 80 00 58 	be,a   20072ec <rtems_fdisk_initialize+0x3b4>  <== ALWAYS TAKEN
 2007190:	b0 10 20 00 	clr  %i0                                       
    {                                                                 
      rtems_semaphore_delete (fd->lock);                              
 2007194:	40 00 15 f7 	call  200c970 <rtems_semaphore_delete>         <== NOT EXECUTED
 2007198:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      rtems_disk_delete (dev);                                        
 200719c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 20071a0:	7f ff f4 c2 	call  20044a8 <rtems_disk_delete>              <== NOT EXECUTED
 20071a4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
      free (fd->copy_buffer);                                         
 20071a8:	40 00 03 8f 	call  2007fe4 <free>                           <== NOT EXECUTED
 20071ac:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
 20071b0:	40 00 03 8d 	call  2007fe4 <free>                           <== NOT EXECUTED
 20071b4:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
 20071b8:	40 00 03 8b 	call  2007fe4 <free>                           <== NOT EXECUTED
 20071bc:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("disk create phy failed");                   
 20071c0:	11 00 80 c5 	sethi  %hi(0x2031400), %o0                     <== NOT EXECUTED
 20071c4:	7f ff f7 62 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20071c8:	90 12 22 b8 	or  %o0, 0x2b8, %o0	! 20316b8 <__FUNCTION__.7127+0xfe0><== NOT EXECUTED
 20071cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20071d0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
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++)           
 20071d4:	84 10 20 00 	clr  %g2                                       
    {                                                                 
      rtems_fdisk_segment_ctl* sc;                                    
      uint32_t                 segment_count;                         
      uint32_t                 segment;                               
                                                                      
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);
 20071d8:	a8 00 40 18 	add  %g1, %i0, %l4                             
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++)           
 20071dc:	da 00 40 18 	ld  [ %g1 + %i0 ], %o5                         
 * Count the segments for a device.                                   
 */                                                                   
static uint32_t                                                       
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)        
{                                                                     
  uint32_t count = 0;                                                 
 20071e0:	a6 10 20 00 	clr  %l3                                       
  uint32_t segment;                                                   
  for (segment = 0; segment < dd->segment_count; segment++)           
 20071e4:	10 80 00 06 	b  20071fc <rtems_fdisk_initialize+0x2c4>      
 20071e8:	82 10 20 00 	clr  %g1                                       
 20071ec:	82 00 60 01 	inc  %g1                                       
    count += dd->segments[segment].count;                             
 20071f0:	c6 10 c0 02 	lduh  [ %g3 + %g2 ], %g3                       
 20071f4:	84 00 a0 0c 	add  %g2, 0xc, %g2                             
 20071f8:	a6 04 c0 03 	add  %l3, %g3, %l3                             
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++)           
 20071fc:	80 a0 40 0d 	cmp  %g1, %o5                                  
 2007200:	32 bf ff fb 	bne,a   20071ec <rtems_fdisk_initialize+0x2b4> 
 2007204:	c6 05 20 04 	ld  [ %l4 + 4 ], %g3                           
      uint32_t                 segment_count;                         
      uint32_t                 segment;                               
                                                                      
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);
                                                                      
      fd->devices[device].segments = calloc (segment_count,           
 2007208:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
 200720c:	90 10 00 13 	mov  %l3, %o0                                  
 2007210:	88 00 40 18 	add  %g1, %i0, %g4                             
 2007214:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
 2007218:	c8 27 bf dc 	st  %g4, [ %fp + -36 ]                         
 200721c:	da 27 bf d4 	st  %o5, [ %fp + -44 ]                         
 2007220:	40 00 02 71 	call  2007be4 <calloc>                         
 2007224:	92 10 20 30 	mov  0x30, %o1                                 
 2007228:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
 200722c:	80 a2 20 00 	cmp  %o0, 0                                    
      uint32_t                 segment_count;                         
      uint32_t                 segment;                               
                                                                      
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);
                                                                      
      fd->devices[device].segments = calloc (segment_count,           
 2007230:	d0 20 40 18 	st  %o0, [ %g1 + %i0 ]                         
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
 2007234:	c8 07 bf dc 	ld  [ %fp + -36 ], %g4                         
 2007238:	12 80 00 23 	bne  20072c4 <rtems_fdisk_initialize+0x38c>    <== ALWAYS TAKEN
 200723c:	da 07 bf d4 	ld  [ %fp + -44 ], %o5                         
      {                                                               
        rtems_disk_delete (dev);                                      
 2007240:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2007244:	7f ff f4 99 	call  20044a8 <rtems_disk_delete>              <== NOT EXECUTED
 2007248:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
        rtems_semaphore_delete (fd->lock);                            
 200724c:	40 00 15 c9 	call  200c970 <rtems_semaphore_delete>         <== NOT EXECUTED
 2007250:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
        free (fd->copy_buffer);                                       
 2007254:	40 00 03 64 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007258:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
        free (fd->blocks);                                            
 200725c:	40 00 03 62 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007260:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
        free (fd->devices);                                           
 2007264:	40 00 03 60 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007268:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
    /*                                                                
     * One copy buffer of a page size.                                
     */                                                               
    fd->copy_buffer = malloc (c->block_size);                         
    if (!fd->copy_buffer)                                             
      return RTEMS_NO_MEMORY;                                         
 200726c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2007270:	91 e8 20 1a 	restore  %g0, 0x1a, %o0                        <== NOT EXECUTED
        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++)
 2007274:	86 10 20 00 	clr  %g3                                       
      for (segment = 0; segment < c->devices[device].segment_count; segment++)
      {                                                               
        const rtems_fdisk_segment_desc* sd;                           
        uint32_t                        seg_segment;                  
                                                                      
        sd = &c->devices[device].segments[segment];                   
 2007278:	96 00 40 02 	add  %g1, %g2, %o3                             
                                                                      
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
 200727c:	d8 10 40 02 	lduh  [ %g1 + %g2 ], %o4                       
 2007280:	10 80 00 07 	b  200729c <rtems_fdisk_initialize+0x364>      
 2007284:	82 10 00 08 	mov  %o0, %g1                                  
        {                                                             
          sc->descriptor = sd;                                        
 2007288:	d6 20 60 04 	st  %o3, [ %g1 + 4 ]                           
          sc->device     = device;                                    
 200728c:	e2 20 60 08 	st  %l1, [ %g1 + 8 ]                           
          sc->segment    = seg_segment;                               
          sc->erased     = 0;                                         
 2007290:	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++)
 2007294:	86 00 e0 01 	inc  %g3                                       
 2007298:	82 00 60 30 	add  %g1, 0x30, %g1                            
 200729c:	80 a0 c0 0c 	cmp  %g3, %o4                                  
 20072a0:	2a bf ff fa 	bcs,a   2007288 <rtems_fdisk_initialize+0x350> 
 20072a4:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
 * @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,              
 20072a8:	83 2b 20 04 	sll  %o4, 4, %g1                               
        return RTEMS_NO_MEMORY;                                       
      }                                                               
                                                                      
      sc = fd->devices[device].segments;                              
                                                                      
      for (segment = 0; segment < c->devices[device].segment_count; segment++)
 20072ac:	9e 03 e0 01 	inc  %o7                                       
 * @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,              
 20072b0:	99 2b 20 06 	sll  %o4, 6, %o4                               
 20072b4:	84 00 a0 0c 	add  %g2, 0xc, %g2                             
 20072b8:	98 23 00 01 	sub  %o4, %g1, %o4                             
 20072bc:	10 80 00 04 	b  20072cc <rtems_fdisk_initialize+0x394>      
 20072c0:	90 02 00 0c 	add  %o0, %o4, %o0                             
                                                                      
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);
                                                                      
      fd->devices[device].segments = calloc (segment_count,           
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
 20072c4:	84 10 20 00 	clr  %g2                                       
 20072c8:	9e 10 20 00 	clr  %o7                                       
        return RTEMS_NO_MEMORY;                                       
      }                                                               
                                                                      
      sc = fd->devices[device].segments;                              
                                                                      
      for (segment = 0; segment < c->devices[device].segment_count; segment++)
 20072cc:	80 a3 c0 0d 	cmp  %o7, %o5                                  
 20072d0:	32 bf ff e9 	bne,a   2007274 <rtems_fdisk_initialize+0x33c> 
 20072d4:	c2 05 20 04 	ld  [ %l4 + 4 ], %g1                           
          sc->segment    = seg_segment;                               
          sc->erased     = 0;                                         
        }                                                             
      }                                                               
                                                                      
      fd->devices[device].segment_count = segment_count;              
 20072d8:	e6 21 20 04 	st  %l3, [ %g4 + 4 ]                           
      fd->devices[device].descriptor    = &c->devices[device];        
 20072dc:	e8 21 20 08 	st  %l4, [ %g4 + 8 ]                           
      free (fd->devices);                                             
      rtems_fdisk_error ("disk create phy failed");                   
      return sc;                                                      
    }                                                                 
                                                                      
    for (device = 0; device < c->device_count; device++)              
 20072e0:	a2 04 60 01 	inc  %l1                                       
 20072e4:	10 80 00 03 	b  20072f0 <rtems_fdisk_initialize+0x3b8>      
 20072e8:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
    }                                                                 
                                                                      
    sc = rtems_disk_create_phys(dev, c->block_size,                   
                                blocks - fd->unavail_blocks,          
                                rtems_fdisk_ioctl, NULL, name);       
    if (sc != RTEMS_SUCCESSFUL)                                       
 20072ec:	a2 10 20 00 	clr  %l1                                       
      free (fd->devices);                                             
      rtems_fdisk_error ("disk create phy failed");                   
      return sc;                                                      
    }                                                                 
                                                                      
    for (device = 0; device < c->device_count; device++)              
 20072f0:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
 20072f4:	80 a4 40 01 	cmp  %l1, %g1                                  
 20072f8:	2a bf ff b7 	bcs,a   20071d4 <rtems_fdisk_initialize+0x29c> 
 20072fc:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
                                                                      
      fd->devices[device].segment_count = segment_count;              
      fd->devices[device].descriptor    = &c->devices[device];        
    }                                                                 
                                                                      
    fd->device_count = c->device_count;                               
 2007300:	c2 26 e0 30 	st  %g1, [ %i3 + 0x30 ]                        
                                                                      
    ret = rtems_fdisk_recover_block_mappings (fd);                    
 2007304:	7f ff f8 46 	call  200541c <rtems_fdisk_recover_block_mappings>
 2007308:	90 10 00 1b 	mov  %i3, %o0                                  
    if (ret)                                                          
 200730c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2007310:	22 80 00 13 	be,a   200735c <rtems_fdisk_initialize+0x424>  <== ALWAYS TAKEN
 2007314:	90 10 00 1b 	mov  %i3, %o0                                  
    {                                                                 
      rtems_disk_delete (dev);                                        
 2007318:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 200731c:	7f ff f4 63 	call  20044a8 <rtems_disk_delete>              <== NOT EXECUTED
 2007320:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
      rtems_semaphore_delete (fd->lock);                              
 2007324:	40 00 15 93 	call  200c970 <rtems_semaphore_delete>         <== NOT EXECUTED
 2007328:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      free (fd->copy_buffer);                                         
 200732c:	40 00 03 2e 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007330:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
 2007334:	40 00 03 2c 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007338:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
 200733c:	40 00 03 2a 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007340:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",          
 2007344:	40 00 6f 7c 	call  2023134 <strerror>                       <== NOT EXECUTED
 2007348:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 200734c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 2007350:	11 00 80 c5 	sethi  %hi(0x2031400), %o0                     <== NOT EXECUTED
 2007354:	10 80 00 17 	b  20073b0 <rtems_fdisk_initialize+0x478>      <== NOT EXECUTED
 2007358:	90 12 22 d0 	or  %o0, 0x2d0, %o0	! 20316d0 <__FUNCTION__.7127+0xff8><== NOT EXECUTED
                         strerror (ret), ret);                        
      return ret;                                                     
    }                                                                 
                                                                      
    ret = rtems_fdisk_compact (fd);                                   
 200735c:	7f ff fa 05 	call  2005b70 <rtems_fdisk_compact>            
 2007360:	a4 04 a0 74 	add  %l2, 0x74, %l2                            
    if (ret)                                                          
 2007364:	80 a2 20 00 	cmp  %o0, 0                                    
 2007368:	02 80 00 16 	be  20073c0 <rtems_fdisk_initialize+0x488>     <== ALWAYS TAKEN
 200736c:	b0 10 00 08 	mov  %o0, %i0                                  
    {                                                                 
      rtems_disk_delete (dev);                                        
 2007370:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2007374:	7f ff f4 4d 	call  20044a8 <rtems_disk_delete>              <== NOT EXECUTED
 2007378:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
      rtems_semaphore_delete (fd->lock);                              
 200737c:	40 00 15 7d 	call  200c970 <rtems_semaphore_delete>         <== NOT EXECUTED
 2007380:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      free (fd->copy_buffer);                                         
 2007384:	40 00 03 18 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007388:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
 200738c:	40 00 03 16 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007390:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
 2007394:	40 00 03 14 	call  2007fe4 <free>                           <== NOT EXECUTED
 2007398:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("compacting of disk failed: %s (%d)",        
 200739c:	40 00 6f 66 	call  2023134 <strerror>                       <== NOT EXECUTED
 20073a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 20073a4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 20073a8:	11 00 80 c5 	sethi  %hi(0x2031400), %o0                     <== NOT EXECUTED
 20073ac:	90 12 22 f8 	or  %o0, 0x2f8, %o0	! 20316f8 <__FUNCTION__.7127+0x1020><== NOT EXECUTED
 20073b0:	7f ff f6 e7 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20073b4:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
 20073b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20073bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
 20073c0:	b2 06 60 01 	inc  %i1                                       
 20073c4:	10 80 00 04 	b  20073d4 <rtems_fdisk_initialize+0x49c>      
 20073c8:	b4 06 a0 20 	add  %i2, 0x20, %i2                            
    /*                                                                
     * One copy buffer of a page size.                                
     */                                                               
    fd->copy_buffer = malloc (c->block_size);                         
    if (!fd->copy_buffer)                                             
      return RTEMS_NO_MEMORY;                                         
 20073cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20073d0:	91 e8 20 1a 	restore  %g0, 0x1a, %o0                        <== NOT EXECUTED
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
 20073d4:	c2 05 e0 9c 	ld  [ %l7 + 0x9c ], %g1                        
 20073d8:	80 a6 40 01 	cmp  %i1, %g1                                  
 20073dc:	2a bf fe f9 	bcs,a   2006fc0 <rtems_fdisk_initialize+0x88>  
 20073e0:	ec 37 bf f8 	sth  %l6, [ %fp + -8 ]                         
                         strerror (ret), ret);                        
      return ret;                                                     
    }                                                                 
  }                                                                   
                                                                      
  rtems_flashdisk_count = rtems_flashdisk_configuration_size;         
 20073e4:	05 00 81 19 	sethi  %hi(0x2046400), %g2                     
 20073e8:	c2 20 a0 84 	st  %g1, [ %g2 + 0x84 ]	! 2046484 <rtems_flashdisk_count>
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 20073ec:	81 c7 e0 08 	ret                                            
 20073f0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  sc = rtems_fdisk_crc16_gen_factors (0x8408);                        
  if (sc != RTEMS_SUCCESSFUL)                                         
      return sc;                                                      
                                                                      
  rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,      
 20073f4:	d0 05 e0 9c 	ld  [ %l7 + 0x9c ], %o0                        
 20073f8:	92 10 20 74 	mov  0x74, %o1                                 
 20073fc:	40 00 01 fa 	call  2007be4 <calloc>                         
 2007400:	2b 00 81 19 	sethi  %hi(0x2046400), %l5                     
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
 2007404:	80 a2 20 00 	cmp  %o0, 0                                    
 2007408:	02 bf ff f1 	be  20073cc <rtems_fdisk_initialize+0x494>     <== NEVER TAKEN
 200740c:	d0 25 60 80 	st  %o0, [ %l5 + 0x80 ]                        
 2007410:	35 00 80 c0 	sethi  %hi(0x2030000), %i2                     
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";           
 2007414:	2d 00 00 18 	sethi  %hi(0x6000), %l6                        
      return sc;                                                      
                                                                      
  rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,      
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
 2007418:	a4 10 20 00 	clr  %l2                                       
 200741c:	b4 16 a2 70 	or  %i2, 0x270, %i2                            
 2007420:	b2 10 20 00 	clr  %i1                                       
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
  {                                                                   
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";           
 2007424:	10 bf ff ec 	b  20073d4 <rtems_fdisk_initialize+0x49c>      
 2007428:	ac 15 a1 00 	or  %l6, 0x100, %l6                            
  }                                                                   
                                                                      
  rtems_flashdisk_count = rtems_flashdisk_configuration_size;         
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 200742c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2007430:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02005da8 <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) {
 2005da8:	9d e3 bf 38 	save  %sp, -200, %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;                                                          
 2005dac:	40 00 6b 1d 	call  2020a20 <__errno>                        
 2005db0:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           
                                                                      
  sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
 2005db4:	83 2f 20 02 	sll  %i4, 2, %g1                               
 2005db8:	b7 2f 20 05 	sll  %i4, 5, %i3                               
 2005dbc:	3b 00 81 19 	sethi  %hi(0x2046400), %i5                     
 2005dc0:	b6 26 c0 01 	sub  %i3, %g1, %i3                             
 2005dc4:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
  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;                                                          
 2005dc8:	c0 22 00 00 	clr  [ %o0 ]                                   
                                                                      
  sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
 2005dcc:	b6 06 c0 1c 	add  %i3, %i4, %i3                             
 2005dd0:	b7 2e e0 02 	sll  %i3, 2, %i3                               
 2005dd4:	82 00 40 1b 	add  %g1, %i3, %g1                             
 2005dd8:	d0 00 60 64 	ld  [ %g1 + 0x64 ], %o0                        
 2005ddc:	92 10 20 00 	clr  %o1                                       
 2005de0:	40 00 1b 13 	call  200ca2c <rtems_semaphore_obtain>         
 2005de4:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 2005de8:	80 a2 20 00 	cmp  %o0, 0                                    
 2005dec:	12 80 04 42 	bne  2006ef4 <rtems_fdisk_ioctl+0x114c>        <== NEVER TAKEN
 2005df0:	01 00 00 00 	nop                                            
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
 2005df4:	40 00 6b 0b 	call  2020a20 <__errno>                        
 2005df8:	01 00 00 00 	nop                                            
    switch (req)                                                      
 2005dfc:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
 2005e00:	84 10 62 83 	or  %g1, 0x283, %g2	! 20004283 <RAM_END+0x1dc04283>
 2005e04:	80 a6 40 02 	cmp  %i1, %g2                                  
 2005e08:	02 80 02 cf 	be  2006944 <rtems_fdisk_ioctl+0xb9c>          <== NEVER TAKEN
 2005e0c:	c0 22 00 00 	clr  [ %o0 ]                                   
 2005e10:	80 a6 40 02 	cmp  %i1, %g2                                  
 2005e14:	38 80 00 0c 	bgu,a   2005e44 <rtems_fdisk_ioctl+0x9c>       
 2005e18:	82 10 62 85 	or  %g1, 0x285, %g1                            
 2005e1c:	84 10 62 81 	or  %g1, 0x281, %g2                            
 2005e20:	80 a6 40 02 	cmp  %i1, %g2                                  
 2005e24:	02 80 02 aa 	be  20068cc <rtems_fdisk_ioctl+0xb24>          <== NEVER TAKEN
 2005e28:	01 00 00 00 	nop                                            
 2005e2c:	18 80 02 b0 	bgu  20068ec <rtems_fdisk_ioctl+0xb44>         <== NEVER TAKEN
 2005e30:	82 10 62 80 	or  %g1, 0x280, %g1                            
 2005e34:	80 a6 40 01 	cmp  %i1, %g1                                  
 2005e38:	32 80 04 24 	bne,a   2006ec8 <rtems_fdisk_ioctl+0x1120>     <== ALWAYS TAKEN
 2005e3c:	90 10 00 18 	mov  %i0, %o0                                  
 2005e40:	30 80 02 67 	b,a   20067dc <rtems_fdisk_ioctl+0xa34>        <== NOT EXECUTED
 2005e44:	80 a6 40 01 	cmp  %i1, %g1                                  
 2005e48:	02 80 03 1f 	be  2006ac4 <rtems_fdisk_ioctl+0xd1c>          
 2005e4c:	01 00 00 00 	nop                                            
 2005e50:	0a 80 03 1a 	bcs  2006ab8 <rtems_fdisk_ioctl+0xd10>         <== NEVER TAKEN
 2005e54:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 2005e58:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
 2005e5c:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <RAM_END+0xbdd84201>
 2005e60:	80 a6 40 01 	cmp  %i1, %g1                                  
 2005e64:	12 80 04 19 	bne  2006ec8 <rtems_fdisk_ioctl+0x1120>        
 2005e68:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
 2005e6c:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     
 2005e70:	c2 00 60 84 	ld  [ %g1 + 0x84 ], %g1	! 2046484 <rtems_flashdisk_count>
 2005e74:	80 a7 00 01 	cmp  %i4, %g1                                  
 2005e78:	1a 80 00 08 	bcc  2005e98 <rtems_fdisk_ioctl+0xf0>          <== NEVER TAKEN
 2005e7c:	01 00 00 00 	nop                                            
            (rtems_flashdisks[minor].device_count == 0))              
 2005e80:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 2005e84:	82 00 40 1b 	add  %g1, %i3, %g1                             
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
 2005e88:	c2 00 60 30 	ld  [ %g1 + 0x30 ], %g1                        
 2005e8c:	80 a0 60 00 	cmp  %g1, 0                                    
 2005e90:	32 80 00 06 	bne,a   2005ea8 <rtems_fdisk_ioctl+0x100>      <== ALWAYS TAKEN
 2005e94:	c2 06 80 00 	ld  [ %i2 ], %g1                               
            (rtems_flashdisks[minor].device_count == 0))              
        {                                                             
          errno = ENODEV;                                             
 2005e98:	40 00 6a e2 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2005e9c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2005ea0:	10 80 02 4d 	b  20067d4 <rtems_fdisk_ioctl+0xa2c>           <== NOT EXECUTED
 2005ea4:	82 10 20 13 	mov  0x13, %g1	! 13 <PROM_START+0x13>          <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
          switch (r->req)                                             
 2005ea8:	80 a0 60 00 	cmp  %g1, 0                                    
 2005eac:	02 80 00 05 	be  2005ec0 <rtems_fdisk_ioctl+0x118>          
 2005eb0:	80 a0 60 01 	cmp  %g1, 1                                    
 2005eb4:	12 80 02 45 	bne  20067c8 <rtems_fdisk_ioctl+0xa20>         <== NEVER TAKEN
 2005eb8:	01 00 00 00 	nop                                            
 2005ebc:	30 80 00 b5 	b,a   2006190 <rtems_fdisk_ioctl+0x3e8>        
          {                                                           
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
 2005ec0:	40 00 6a d8 	call  2020a20 <__errno>                        
 2005ec4:	b0 06 a0 18 	add  %i2, 0x18, %i0                            
 2005ec8:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
 2005ecc:	d0 27 bf ec 	st  %o0, [ %fp + -20 ]                         
 2005ed0:	b8 07 00 1b 	add  %i4, %i3, %i4                             
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
 2005ed4:	10 80 00 a2 	b  200615c <rtems_fdisk_ioctl+0x3b4>           
 2005ed8:	a4 10 20 00 	clr  %l2                                       
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
 2005edc:	d2 07 20 14 	ld  [ %i4 + 0x14 ], %o1                        
 2005ee0:	7f ff f1 e7 	call  200267c <.udiv>                          
 2005ee4:	a2 10 20 00 	clr  %l1                                       
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
 2005ee8:	2d 00 80 c3 	sethi  %hi(0x2030c00), %l6                     
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
 2005eec:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         
    data = sg->buffer;                                                
 2005ef0:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
 2005ef4:	10 80 00 91 	b  2006138 <rtems_fdisk_ioctl+0x390>           
 2005ef8:	2f 00 80 c3 	sethi  %hi(0x2030c00), %l7                     
  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);                      
 2005efc:	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);         
 2005f00:	b2 04 40 19 	add  %l1, %i1, %i1                             
  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);                      
 2005f04:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2005f08:	94 10 00 19 	mov  %i1, %o2                                  
 2005f0c:	7f ff fb b0 	call  2004dcc <rtems_fdisk_info>               
 2005f10:	92 12 60 80 	or  %o1, 0x80, %o1                             
                                                                      
  /*                                                                  
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
 2005f14:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
 2005f18:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
 2005f1c:	82 20 80 01 	sub  %g2, %g1, %g1                             
 2005f20:	80 a6 40 01 	cmp  %i1, %g1                                  
 2005f24:	2a 80 00 08 	bcs,a   2005f44 <rtems_fdisk_ioctl+0x19c>      <== ALWAYS TAKEN
 2005f28:	c6 07 20 18 	ld  [ %i4 + 0x18 ], %g3                        
  {                                                                   
    rtems_fdisk_error ("read-block: block out of range: %d", block);  
 2005f2c:	11 00 80 c4 	sethi  %hi(0x2031000), %o0                     <== NOT EXECUTED
 2005f30:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2005f34:	7f ff fc 06 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005f38:	90 12 20 90 	or  %o0, 0x90, %o0                             <== 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)                  
 2005f3c:	10 80 00 84 	b  200614c <rtems_fdisk_ioctl+0x3a4>           <== NOT EXECUTED
 2005f40:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_error ("read-block: block out of range: %d", block);  
    return EIO;                                                       
  }                                                                   
                                                                      
  bc = &fd->blocks[block];                                            
 2005f44:	83 2e 60 03 	sll  %i1, 3, %g1                               
                                                                      
  if (!bc->segment)                                                   
 2005f48:	fa 00 c0 01 	ld  [ %g3 + %g1 ], %i5                         
 2005f4c:	80 a7 60 00 	cmp  %i5, 0                                    
 2005f50:	12 80 00 0d 	bne  2005f84 <rtems_fdisk_ioctl+0x1dc>         
 2005f54:	aa 00 c0 01 	add  %g3, %g1, %l5                             
  {                                                                   
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
 2005f58:	94 10 00 19 	mov  %i1, %o2                                  
 2005f5c:	90 10 00 1c 	mov  %i4, %o0                                  
 2005f60:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2005f64:	7f ff fb 9a 	call  2004dcc <rtems_fdisk_info>               
 2005f68:	92 12 60 b8 	or  %o1, 0xb8, %o1	! 20310b8 <__FUNCTION__.7127+0x9e0>
#endif                                                                
    memset (buffer, 0xff, fd->block_size);                            
 2005f6c:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
 2005f70:	90 10 00 10 	mov  %l0, %o0                                  
 2005f74:	40 00 6f 86 	call  2021d8c <memset>                         
 2005f78:	92 10 20 ff 	mov  0xff, %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)                  
 2005f7c:	10 80 03 ea 	b  2006f24 <rtems_fdisk_ioctl+0x117c>          
 2005f80:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
    memset (buffer, 0xff, fd->block_size);                            
    return 0;                                                         
  }                                                                   
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
 2005f84:	da 05 60 04 	ld  [ %l5 + 4 ], %o5                           
 2005f88:	e8 07 60 10 	ld  [ %i5 + 0x10 ], %l4                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
 2005f8c:	c8 07 40 00 	ld  [ %i5 ], %g4                               
    memset (buffer, 0xff, fd->block_size);                            
    return 0;                                                         
  }                                                                   
                                                                      
  sc = fd->blocks[block].segment;                                     
  pd = &sc->page_descriptors[bc->page];                               
 2005f90:	a7 2b 60 03 	sll  %o5, 3, %l3                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
 2005f94:	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];                               
 2005f98:	86 05 00 13 	add  %l4, %l3, %g3                             
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
 2005f9c:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
 2005fa0:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
 2005fa4:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
 2005fa8:	d4 07 60 20 	ld  [ %i5 + 0x20 ], %o2                        
 2005fac:	80 a1 20 00 	cmp  %g4, 0                                    
 2005fb0:	02 80 00 04 	be  2005fc0 <rtems_fdisk_ioctl+0x218>          
 2005fb4:	de 07 60 24 	ld  [ %i5 + 0x24 ], %o7                        
 2005fb8:	10 80 00 03 	b  2005fc4 <rtems_fdisk_ioctl+0x21c>           
 2005fbc:	88 15 e0 18 	or  %l7, 0x18, %g4                             
 2005fc0:	88 15 a0 20 	or  %l6, 0x20, %g4                             
 2005fc4:	d0 23 a0 5c 	st  %o0, [ %sp + 0x5c ]                        
 2005fc8:	d2 23 a0 60 	st  %o1, [ %sp + 0x60 ]                        
 2005fcc:	d4 23 a0 64 	st  %o2, [ %sp + 0x64 ]                        
 2005fd0:	de 23 a0 68 	st  %o7, [ %sp + 0x68 ]                        
 2005fd4:	c8 23 a0 6c 	st  %g4, [ %sp + 0x6c ]                        
 2005fd8:	c8 10 e0 02 	lduh  [ %g3 + 2 ], %g4                         
 2005fdc:	90 10 00 1c 	mov  %i4, %o0                                  
 2005fe0:	c8 23 a0 70 	st  %g4, [ %sp + 0x70 ]                        
 2005fe4:	c8 15 00 13 	lduh  [ %l4 + %l3 ], %g4                       
 2005fe8:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2005fec:	c8 23 a0 74 	st  %g4, [ %sp + 0x74 ]                        
 2005ff0:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
 2005ff4:	92 12 60 e0 	or  %o1, 0xe0, %o1                             
 2005ff8:	c6 27 bf d4 	st  %g3, [ %fp + -44 ]                         
 2005ffc:	c8 23 a0 78 	st  %g4, [ %sp + 0x78 ]                        
 2006000:	7f ff fb 73 	call  2004dcc <rtems_fdisk_info>               
 2006004:	94 10 00 19 	mov  %i1, %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;                     
 2006008:	c6 07 bf d4 	ld  [ %fp + -44 ], %g3                         
 200600c:	c6 10 e0 02 	lduh  [ %g3 + 2 ], %g3                         
                    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))  
 2006010:	80 88 e0 01 	btst  1, %g3                                   
 2006014:	12 80 00 41 	bne  2006118 <rtems_fdisk_ioctl+0x370>         <== NEVER TAKEN
 2006018:	d8 05 60 04 	ld  [ %l5 + 4 ], %o4                           
  {                                                                   
    if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
 200601c:	80 88 e0 02 	btst  2, %g3                                   
 2006020:	02 80 00 3c 	be  2006110 <rtems_fdisk_ioctl+0x368>          <== NEVER TAKEN
 2006024:	11 00 80 c4 	sethi  %hi(0x2031000), %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);
 2006028:	c6 07 20 14 	ld  [ %i4 + 0x14 ], %g3                        
                                                                      
      /*                                                              
       * 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,                    
 200602c:	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,                                
 2006030:	92 10 00 03 	mov  %g3, %o1                                  
 2006034:	90 02 00 0c 	add  %o0, %o4, %o0                             
 2006038:	7f ff f1 57 	call  2002594 <.umul>                          
 200603c:	c6 27 bf d4 	st  %g3, [ %fp + -44 ]                         
 2006040:	c6 07 bf d4 	ld  [ %fp + -44 ], %g3                         
 2006044:	94 10 00 08 	mov  %o0, %o2                                  
 2006048:	98 10 00 03 	mov  %g3, %o4                                  
 200604c:	90 10 00 1c 	mov  %i4, %o0                                  
 2006050:	92 10 00 1d 	mov  %i5, %o1                                  
 2006054:	7f ff fc 78 	call  2005234 <rtems_fdisk_seg_read>           
 2006058:	96 10 00 10 	mov  %l0, %o3                                  
       * driver. This skips the page descriptors.                     
       */                                                             
      int ret = rtems_fdisk_seg_read_page (fd, sc,                    
                                           bc->page + sc->pages_desc, buffer);
                                                                      
      if (ret)                                                        
 200605c:	86 92 20 00 	orcc  %o0, 0, %g3                              
 2006060:	22 80 00 13 	be,a   20060ac <rtems_fdisk_ioctl+0x304>       <== ALWAYS TAKEN
 2006064:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     
      {                                                               
#if RTEMS_FDISK_TRACE                                                 
        rtems_fdisk_info (fd,                                         
 2006068:	e0 07 60 08 	ld  [ %i5 + 8 ], %l0                           <== NOT EXECUTED
 200606c:	f2 07 60 0c 	ld  [ %i5 + 0xc ], %i1                         <== NOT EXECUTED
 2006070:	fa 05 60 04 	ld  [ %l5 + 4 ], %i5                           <== NOT EXECUTED
 2006074:	40 00 74 30 	call  2023134 <strerror>                       <== NOT EXECUTED
 2006078:	c6 27 bf d4 	st  %g3, [ %fp + -44 ]                         <== NOT EXECUTED
 200607c:	c6 07 bf d4 	ld  [ %fp + -44 ], %g3                         <== NOT EXECUTED
 2006080:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
 2006084:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        <== NOT EXECUTED
 2006088:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 200608c:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     <== NOT EXECUTED
 2006090:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 2006094:	92 12 61 28 	or  %o1, 0x128, %o1                            <== NOT EXECUTED
 2006098:	96 10 00 19 	mov  %i1, %o3                                  <== NOT EXECUTED
 200609c:	7f ff fb 4c 	call  2004dcc <rtems_fdisk_info>               <== NOT EXECUTED
 20060a0:	98 10 00 1d 	mov  %i5, %o4                                  <== 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)                  
 20060a4:	10 80 00 2a 	b  200614c <rtems_fdisk_ioctl+0x3a4>           <== NOT EXECUTED
 20060a8:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
                          strerror (ret), ret);                       
#endif                                                                
        return ret;                                                   
      }                                                               
                                                                      
      cs = rtems_fdisk_page_checksum (buffer, fd->block_size);        
 20060ac:	c6 07 20 14 	ld  [ %i4 + 0x14 ], %g3                        
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
 20060b0:	c8 00 60 88 	ld  [ %g1 + 0x88 ], %g4                        
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++)                           
 20060b4:	84 10 20 00 	clr  %g2                                       
 * 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;                                               
 20060b8:	10 80 00 09 	b  20060dc <rtems_fdisk_ioctl+0x334>           
 20060bc:	94 10 3f ff 	mov  -1, %o2                                   
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
 20060c0:	fa 0c 00 02 	ldub  [ %l0 + %g2 ], %i5                       
 20060c4:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
 20060c8:	94 1f 40 0a 	xor  %i5, %o2, %o2                             
 20060cc:	94 0a a0 ff 	and  %o2, 0xff, %o2                            
 20060d0:	95 2a a0 01 	sll  %o2, 1, %o2                               
 20060d4:	d4 11 00 0a 	lduh  [ %g4 + %o2 ], %o2                       
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++)                           
 20060d8:	84 00 a0 01 	inc  %g2                                       
 20060dc:	80 a0 80 03 	cmp  %g2, %g3                                  
 20060e0:	12 bf ff f8 	bne  20060c0 <rtems_fdisk_ioctl+0x318>         
 20060e4:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
        return ret;                                                   
      }                                                               
                                                                      
      cs = rtems_fdisk_page_checksum (buffer, fd->block_size);        
                                                                      
      if (cs == pd->crc)                                              
 20060e8:	d6 15 00 13 	lduh  [ %l4 + %l3 ], %o3                       
 20060ec:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
 20060f0:	80 a2 80 0b 	cmp  %o2, %o3                                  
 20060f4:	02 80 03 8b 	be  2006f20 <rtems_fdisk_ioctl+0x1178>         <== ALWAYS TAKEN
 20060f8:	11 00 80 c4 	sethi  %hi(0x2031000), %o0                     
        return 0;                                                     
                                                                      
      rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
 20060fc:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2006100:	7f ff fb 93 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2006104:	90 12 21 60 	or  %o0, 0x160, %o0                            <== 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)                  
 2006108:	10 80 00 11 	b  200614c <rtems_fdisk_ioctl+0x3a4>           <== NOT EXECUTED
 200610c:	82 10 20 01 	mov  1, %g1                                    <== 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",
 2006110:	10 80 00 04 	b  2006120 <rtems_fdisk_ioctl+0x378>           <== NOT EXECUTED
 2006114:	90 12 21 98 	or  %o0, 0x198, %o0                            <== NOT EXECUTED
                         block, sc->device, sc->segment, bc->page);   
    }                                                                 
  }                                                                   
  else                                                                
  {                                                                   
    rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
 2006118:	11 00 80 c4 	sethi  %hi(0x2031000), %o0                     <== NOT EXECUTED
 200611c:	90 12 21 d0 	or  %o0, 0x1d0, %o0	! 20311d0 <__FUNCTION__.7127+0xaf8><== NOT EXECUTED
 2006120:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           <== NOT EXECUTED
 2006124:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         <== NOT EXECUTED
 2006128:	7f ff fb 89 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 200612c:	92 10 00 19 	mov  %i1, %o1                                  <== 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)                  
 2006130:	10 80 03 80 	b  2006f30 <rtems_fdisk_ioctl+0x1188>          <== NOT EXECUTED
 2006134:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2006138:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2                         
 200613c:	80 a4 40 02 	cmp  %l1, %g2                                  
 2006140:	32 bf ff 6f 	bne,a   2005efc <rtems_fdisk_ioctl+0x154>      
 2006144:	f2 06 00 00 	ld  [ %i0 ], %i1                               
 2006148:	82 10 20 00 	clr  %g1                                       
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
 200614c:	a4 04 a0 01 	inc  %l2                                       
 2006150:	80 a0 60 00 	cmp  %g1, 0                                    
 2006154:	12 80 00 08 	bne  2006174 <rtems_fdisk_ioctl+0x3cc>         <== NEVER TAKEN
 2006158:	b0 06 20 10 	add  %i0, 0x10, %i0                            
 200615c:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
 2006160:	80 a4 80 01 	cmp  %l2, %g1                                  
 2006164:	2a bf ff 5e 	bcs,a   2005edc <rtems_fdisk_ioctl+0x134>      
 2006168:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
 200616c:	10 80 00 03 	b  2006178 <rtems_fdisk_ioctl+0x3d0>           
 2006170:	92 10 20 00 	clr  %o1                                       
 2006174:	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);                                          
 2006178:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
 200617c:	9f c0 40 00 	call  %g1                                      
 2006180:	90 10 00 1a 	mov  %i2, %o0                                  
        else                                                          
        {                                                             
          switch (r->req)                                             
          {                                                           
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
 2006184:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
              break;                                                  
 2006188:	10 80 03 53 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          
 200618c:	c0 20 40 00 	clr  [ %g1 ]                                   
                                                                      
            case RTEMS_BLKDEV_REQ_WRITE:                              
              errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
 2006190:	40 00 6a 24 	call  2020a20 <__errno>                        
 2006194:	a0 06 a0 18 	add  %i2, 0x18, %l0                            
 2006198:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     
 200619c:	fa 00 60 80 	ld  [ %g1 + 0x80 ], %i5	! 2046480 <rtems_flashdisks>
 20061a0:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         
 20061a4:	ba 07 40 1b 	add  %i5, %i3, %i5                             
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
 20061a8:	10 80 01 7c 	b  2006798 <rtems_fdisk_ioctl+0x9f0>           
 20061ac:	aa 10 20 00 	clr  %l5                                       
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
 20061b0:	d2 07 60 14 	ld  [ %i5 + 0x14 ], %o1                        
 20061b4:	7f ff f1 32 	call  200267c <.udiv>                          
 20061b8:	a4 10 20 00 	clr  %l2                                       
    data = sg->buffer;                                                
 20061bc:	e2 04 20 08 	ld  [ %l0 + 8 ], %l1                           
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
 20061c0:	10 80 01 6d 	b  2006774 <rtems_fdisk_ioctl+0x9cc>           
 20061c4:	d0 27 bf e4 	st  %o0, [ %fp + -28 ]                         
  rtems_fdisk_page_desc*   pd;                                        
  uint32_t                 page;                                      
  int                      ret;                                       
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "write-block:%d", block);                     
 20061c8:	90 10 00 1d 	mov  %i5, %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_write_block (fd, sg->block + b, data);        
 20061cc:	b2 04 80 19 	add  %l2, %i1, %i1                             
  rtems_fdisk_page_desc*   pd;                                        
  uint32_t                 page;                                      
  int                      ret;                                       
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "write-block:%d", block);                     
 20061d0:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 20061d4:	94 10 00 19 	mov  %i1, %o2                                  
 20061d8:	7f ff fa fd 	call  2004dcc <rtems_fdisk_info>               
 20061dc:	92 12 62 00 	or  %o1, 0x200, %o1                            
                                                                      
  /*                                                                  
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
 20061e0:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        
 20061e4:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 20061e8:	82 20 80 01 	sub  %g2, %g1, %g1                             
 20061ec:	80 a6 40 01 	cmp  %i1, %g1                                  
 20061f0:	2a 80 00 08 	bcs,a   2006210 <rtems_fdisk_ioctl+0x468>      <== ALWAYS TAKEN
 20061f4:	ee 07 60 18 	ld  [ %i5 + 0x18 ], %l7                        
  {                                                                   
    rtems_fdisk_error ("write-block: block out of range: %d", block); 
 20061f8:	11 00 80 c4 	sethi  %hi(0x2031000), %o0                     <== NOT EXECUTED
 20061fc:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2006200:	7f ff fb 53 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2006204:	90 12 22 10 	or  %o0, 0x210, %o0                            <== NOT EXECUTED
                     sc->device, sc->segment);                        
                                                                      
  sc->failed = true;                                                  
  rtems_fdisk_queue_segment (fd, sc);                                 
                                                                      
  return EIO;                                                         
 2006208:	10 80 01 60 	b  2006788 <rtems_fdisk_ioctl+0x9e0>           <== NOT EXECUTED
 200620c:	b2 10 20 05 	mov  5, %i1                                    <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_error ("write-block: block out of range: %d", block); 
    return EIO;                                                       
  }                                                                   
                                                                      
  bc = &fd->blocks[block];                                            
 2006210:	ad 2e 60 03 	sll  %i1, 3, %l6                               
                                                                      
  /*                                                                  
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
 2006214:	f8 05 c0 16 	ld  [ %l7 + %l6 ], %i4                         
 2006218:	80 a7 20 00 	cmp  %i4, 0                                    
 200621c:	02 80 00 97 	be  2006478 <rtems_fdisk_ioctl+0x6d0>          
 2006220:	b0 05 c0 16 	add  %l7, %l6, %i0                             
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
 2006224:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 2006228:	c4 07 20 10 	ld  [ %i4 + 0x10 ], %g2                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
 200622c:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           
 2006230:	d6 07 20 0c 	ld  [ %i4 + 0xc ], %o3                         
 2006234:	98 10 00 01 	mov  %g1, %o4                                  
 2006238:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
 200623c:	c4 27 bf e0 	st  %g2, [ %fp + -32 ]                         
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
 2006240:	90 10 00 1d 	mov  %i5, %o0                                  
 2006244:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2006248:	7f ff fa e1 	call  2004dcc <rtems_fdisk_info>               
 200624c:	92 12 62 38 	or  %o1, 0x238, %o1	! 2031238 <__FUNCTION__.7127+0xb60>
                             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);
 2006250:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
#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,     
 2006254:	d0 07 20 18 	ld  [ %i4 + 0x18 ], %o0                        
                             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);
 2006258:	c4 27 bf ec 	st  %g2, [ %fp + -20 ]                         
#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,     
 200625c:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
                             uint32_t               device,           
                             uint32_t               segment,          
                             uint32_t               page,             
                             const void*            buffer)           
{                                                                     
  return rtems_fdisk_seg_verify (fd, device, segment,                 
 2006260:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         
#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,     
 2006264:	e8 07 20 08 	ld  [ %i4 + 8 ], %l4                           
                             uint32_t               device,           
                             uint32_t               segment,          
                             uint32_t               page,             
                             const void*            buffer)           
{                                                                     
  return rtems_fdisk_seg_verify (fd, device, segment,                 
 2006268:	7f ff f0 cb 	call  2002594 <.umul>                          
 200626c:	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;            
 2006270:	89 2d 20 04 	sll  %l4, 4, %g4                               
 2006274:	87 2d 20 02 	sll  %l4, 2, %g3                               
 2006278:	86 21 00 03 	sub  %g4, %g3, %g3                             
 200627c:	c8 07 60 2c 	ld  [ %i5 + 0x2c ], %g4                        
#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,     
 2006280:	e6 07 20 0c 	ld  [ %i4 + 0xc ], %l3                         
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;            
 2006284:	9e 01 00 03 	add  %g4, %g3, %o7                             
 2006288:	c8 01 00 03 	ld  [ %g4 + %g3 ], %g4                         
 200628c:	9b 2c e0 06 	sll  %l3, 6, %o5                               
 2006290:	87 2c e0 04 	sll  %l3, 4, %g3                               
 2006294:	86 23 40 03 	sub  %o5, %g3, %g3                             
 2006298:	86 01 00 03 	add  %g4, %g3, %g3                             
 200629c:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
                        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;                    
 20062a0:	c6 03 e0 08 	ld  [ %o7 + 8 ], %g3                           
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-verify: %02d-%03d: o=%08x s=%d",     
 20062a4:	da 07 bf ec 	ld  [ %fp + -20 ], %o5                         
                        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;                    
 20062a8:	c6 00 e0 08 	ld  [ %g3 + 8 ], %g3                           
                             uint32_t               device,           
                             uint32_t               segment,          
                             uint32_t               page,             
                             const void*            buffer)           
{                                                                     
  return rtems_fdisk_seg_verify (fd, device, segment,                 
 20062ac:	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",     
 20062b0:	94 10 00 14 	mov  %l4, %o2                                  
 20062b4:	98 10 00 02 	mov  %g2, %o4                                  
 20062b8:	c4 3f bf d0 	std  %g2, [ %fp + -48 ]                        
 20062bc:	96 10 00 13 	mov  %l3, %o3                                  
 20062c0:	c8 27 bf cc 	st  %g4, [ %fp + -52 ]                         
 20062c4:	90 10 00 1d 	mov  %i5, %o0                                  
 20062c8:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 20062cc:	7f ff fa e0 	call  2004e4c <rtems_fdisk_printf>             
 20062d0:	92 12 62 60 	or  %o1, 0x260, %o1	! 2031260 <__FUNCTION__.7127+0xb88>
                      device, segment, offset, size);                 
#endif                                                                
  return ops->verify (sd, device, segment, offset, buffer, size);     
 20062d4:	c6 07 bf d4 	ld  [ %fp + -44 ], %g3                         
 20062d8:	c8 07 bf cc 	ld  [ %fp + -52 ], %g4                         
 20062dc:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
 20062e0:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
 20062e4:	da 07 bf ec 	ld  [ %fp + -20 ], %o5                         
 20062e8:	92 10 00 14 	mov  %l4, %o1                                  
 20062ec:	90 10 00 04 	mov  %g4, %o0                                  
 20062f0:	94 10 00 13 	mov  %l3, %o2                                  
 20062f4:	96 10 00 02 	mov  %g2, %o3                                  
 20062f8:	9f c0 c0 00 	call  %g3                                      
 20062fc:	98 10 00 11 	mov  %l1, %o4                                  
#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,     
 2006300:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 2006304:	80 a2 20 00 	cmp  %o0, 0                                    
 2006308:	12 80 00 0c 	bne  2006338 <rtems_fdisk_ioctl+0x590>         
 200630c:	e8 06 20 04 	ld  [ %i0 + 4 ], %l4                           
                                     bc->page + sc->pages_desc, buffer) == 0)
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
 2006310:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           
 2006314:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
 2006318:	90 10 00 1d 	mov  %i5, %o0                                  
 200631c:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2006320:	94 10 00 19 	mov  %i1, %o2                                  
 2006324:	92 12 62 88 	or  %o1, 0x288, %o1                            
 2006328:	7f ff fa a9 	call  2004dcc <rtems_fdisk_info>               
 200632c:	9a 10 00 14 	mov  %l4, %o5                                  
    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)                  
 2006330:	10 80 01 0f 	b  200676c <rtems_fdisk_ioctl+0x9c4>           
 2006334:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
 2006338:	c4 07 bf e0 	ld  [ %fp + -32 ], %g2                         
 200633c:	83 28 60 03 	sll  %g1, 3, %g1                               
 2006340:	82 00 80 01 	add  %g2, %g1, %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;                                                
 2006344:	c4 10 60 02 	lduh  [ %g1 + 2 ], %g2                         
                                       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))             
 2006348:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
 * 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;                                                
 200634c:	84 08 bf fd 	and  %g2, -3, %g2                              
 2006350:	c4 30 60 02 	sth  %g2, [ %g1 + 2 ]                          
                                       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))             
 2006354:	80 88 e0 08 	btst  8, %g3                                   
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)) +        
 2006358:	85 2d 20 03 	sll  %l4, 3, %g2                               
                     ((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
 200635c:	02 80 00 20 	be  20063dc <rtems_fdisk_ioctl+0x634>          <== NEVER TAKEN
 2006360:	84 00 a0 02 	add  %g2, 2, %g2                               
  {                                                                   
    uint16_t flash_flags;                                             
    int      ret;                                                     
    ret = rtems_fdisk_seg_read (fd, sc, offset,                       
 2006364:	94 10 00 02 	mov  %g2, %o2                                  
 2006368:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
 200636c:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         
 2006370:	90 10 00 1d 	mov  %i5, %o0                                  
 2006374:	92 10 00 1c 	mov  %i4, %o1                                  
 2006378:	96 07 bf f6 	add  %fp, -10, %o3                             
 200637c:	7f ff fb ae 	call  2005234 <rtems_fdisk_seg_read>           
 2006380:	98 10 20 02 	mov  2, %o4                                    
                                &flash_flags, sizeof (flash_flags));  
    if (ret)                                                          
 2006384:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 2006388:	a6 92 20 00 	orcc  %o0, 0, %l3                              
 200638c:	12 80 00 1d 	bne  2006400 <rtems_fdisk_ioctl+0x658>         <== NEVER TAKEN
 2006390:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
      return ret;                                                     
    if ((flash_flags & page_desc->flags) != page_desc->flags)         
 2006394:	c6 10 60 02 	lduh  [ %g1 + 2 ], %g3                         
 2006398:	d8 17 bf f6 	lduh  [ %fp + -10 ], %o4                       
 200639c:	88 08 c0 0c 	and  %g3, %o4, %g4                             
 20063a0:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 20063a4:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 20063a8:	80 a1 00 03 	cmp  %g4, %g3                                  
 20063ac:	02 80 00 0c 	be  20063dc <rtems_fdisk_ioctl+0x634>          <== ALWAYS TAKEN
 20063b0:	9b 30 e0 10 	srl  %g3, 0x10, %o5                            
    {                                                                 
      rtems_fdisk_error ("  seg-write-page-flags: %02d-%03d-%03d: "   
 20063b4:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           <== NOT EXECUTED
 20063b8:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         <== NOT EXECUTED
 20063bc:	99 2b 20 10 	sll  %o4, 0x10, %o4                            <== NOT EXECUTED
 20063c0:	11 00 80 c4 	sethi  %hi(0x2031000), %o0                     <== NOT EXECUTED
 20063c4:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
 20063c8:	99 33 20 10 	srl  %o4, 0x10, %o4                            <== NOT EXECUTED
 20063cc:	7f ff fa e0 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20063d0:	90 12 22 b8 	or  %o0, 0x2b8, %o0                            <== NOT EXECUTED
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
 20063d4:	10 80 00 1b 	b  2006440 <rtems_fdisk_ioctl+0x698>           <== NOT EXECUTED
 20063d8:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        <== NOT EXECUTED
                         sc->device, sc->segment, page,               
                         flash_flags, page_desc->flags);              
      return ret;                                                     
    }                                                                 
  }                                                                   
  return rtems_fdisk_seg_write (fd, sc, offset,                       
 20063dc:	90 10 00 1d 	mov  %i5, %o0                                  
 20063e0:	92 10 00 1c 	mov  %i4, %o1                                  
 20063e4:	94 10 00 02 	mov  %g2, %o2                                  
 20063e8:	96 00 60 02 	add  %g1, 2, %o3                               
 20063ec:	7f ff fb d5 	call  2005340 <rtems_fdisk_seg_write>          
 20063f0:	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)                                                          
 20063f4:	a6 92 20 00 	orcc  %o0, 0, %l3                              
 20063f8:	22 80 00 12 	be,a   2006440 <rtems_fdisk_ioctl+0x698>       <== ALWAYS TAKEN
 20063fc:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, " write:%02d-%03d-%03d: "      \          
 2006400:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           <== NOT EXECUTED
 2006404:	d6 07 20 0c 	ld  [ %i4 + 0xc ], %o3                         <== NOT EXECUTED
 2006408:	e8 06 20 04 	ld  [ %i0 + 4 ], %l4                           <== NOT EXECUTED
 200640c:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
 2006410:	40 00 73 49 	call  2023134 <strerror>                       <== NOT EXECUTED
 2006414:	d4 3f bf c0 	std  %o2, [ %fp + -64 ]                        <== NOT EXECUTED
 2006418:	d4 1f bf c0 	ldd  [ %fp + -64 ], %o2                        <== NOT EXECUTED
 200641c:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
 2006420:	e6 23 a0 5c 	st  %l3, [ %sp + 0x5c ]                        <== NOT EXECUTED
 2006424:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2006428:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     <== NOT EXECUTED
 200642c:	98 10 00 14 	mov  %l4, %o4                                  <== NOT EXECUTED
 2006430:	7f ff fa 67 	call  2004dcc <rtems_fdisk_info>               <== NOT EXECUTED
 2006434:	92 12 63 08 	or  %o1, 0x308, %o1                            <== 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);                               
 2006438:	10 80 00 08 	b  2006458 <rtems_fdisk_ioctl+0x6b0>           <== NOT EXECUTED
 200643c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
 2006440:	82 00 7f ff 	add  %g1, -1, %g1                              
 2006444:	c2 27 20 1c 	st  %g1, [ %i4 + 0x1c ]                        
      sc->pages_used++;                                               
 2006448:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
 200644c:	82 00 60 01 	inc  %g1                                       
 2006450:	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);                               
 2006454:	90 10 00 1d 	mov  %i5, %o0                                  
 2006458:	7f ff fb 1a 	call  20050c0 <rtems_fdisk_queue_segment>      
 200645c:	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)            
 2006460:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 2006464:	80 88 60 02 	btst  2, %g1                                   
 2006468:	12 80 00 05 	bne  200647c <rtems_fdisk_ioctl+0x6d4>         <== NEVER TAKEN
 200646c:	b8 07 60 34 	add  %i5, 0x34, %i4                            
      rtems_fdisk_compact (fd);                                       
 2006470:	7f ff fd c0 	call  2005b70 <rtems_fdisk_compact>            
 2006474:	90 10 00 1d 	mov  %i5, %o0                                  
  /*                                                                  
   * Is it time to compact the disk ?                                 
   *                                                                  
   * We override the background compaction configruation.             
   */                                                                 
  if (rtems_fdisk_segment_count_queue (&fd->available) <=             
 2006478:	b8 07 60 34 	add  %i5, 0x34, %i4                            
 200647c:	7f ff f9 f4 	call  2004c4c <rtems_fdisk_segment_count_queue>
 2006480:	90 10 00 1c 	mov  %i4, %o0                                  
 2006484:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 2006488:	80 a2 00 01 	cmp  %o0, %g1                                  
 200648c:	18 80 00 04 	bgu  200649c <rtems_fdisk_ioctl+0x6f4>         
 2006490:	01 00 00 00 	nop                                            
      fd->avail_compact_segs)                                         
    rtems_fdisk_compact (fd);                                         
 2006494:	7f ff fd b7 	call  2005b70 <rtems_fdisk_compact>            
 2006498:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  /*                                                                  
   * Get the next avaliable segment.                                  
   */                                                                 
  sc = rtems_fdisk_segment_queue_pop_head (&fd->available);           
 200649c:	7f ff f9 98 	call  2004afc <rtems_fdisk_segment_queue_pop_head>
 20064a0:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  /*                                                                  
   * Is the flash disk full ?                                         
   */                                                                 
  if (!sc)                                                            
 20064a4:	a6 92 20 00 	orcc  %o0, 0, %l3                              
 20064a8:	32 80 00 13 	bne,a   20064f4 <rtems_fdisk_ioctl+0x74c>      <== ALWAYS TAKEN
 20064ac:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %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))                 
 20064b0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
 20064b4:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
 20064b8:	02 80 00 04 	be  20064c8 <rtems_fdisk_ioctl+0x720>          <== NOT EXECUTED
 20064bc:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_fdisk_compact (fd);                                       
 20064c0:	7f ff fd ac 	call  2005b70 <rtems_fdisk_compact>            <== NOT EXECUTED
 20064c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * Try again for some free space.                                 
     */                                                               
    sc = rtems_fdisk_segment_queue_pop_head (&fd->available);         
 20064c8:	7f ff f9 8d 	call  2004afc <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
 20064cc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
    if (!sc)                                                          
 20064d0:	a6 92 20 00 	orcc  %o0, 0, %l3                              <== NOT EXECUTED
 20064d4:	32 80 00 08 	bne,a   20064f4 <rtems_fdisk_ioctl+0x74c>      <== NOT EXECUTED
 20064d8:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        <== NOT EXECUTED
    {                                                                 
      rtems_fdisk_error ("write-block: no available pages");          
 20064dc:	11 00 80 c4 	sethi  %hi(0x2031000), %o0                     <== NOT EXECUTED
      return ENOSPC;                                                  
 20064e0:	b2 10 20 1c 	mov  0x1c, %i1                                 <== NOT EXECUTED
     */                                                               
    sc = rtems_fdisk_segment_queue_pop_head (&fd->available);         
                                                                      
    if (!sc)                                                          
    {                                                                 
      rtems_fdisk_error ("write-block: no available pages");          
 20064e4:	7f ff fa 9a 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20064e8:	90 12 23 48 	or  %o0, 0x348, %o0                            <== NOT EXECUTED
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
 20064ec:	10 80 00 a8 	b  200678c <rtems_fdisk_ioctl+0x9e4>           <== NOT EXECUTED
 20064f0:	aa 05 60 01 	inc  %l5                                       <== NOT EXECUTED
      return ENOSPC;                                                  
    }                                                                 
  }                                                                   
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  if (fd->info_level >= 3)                                            
 20064f4:	80 a0 60 02 	cmp  %g1, 2                                    
 20064f8:	28 80 00 0f 	bleu,a   2006534 <rtems_fdisk_ioctl+0x78c>     <== ALWAYS TAKEN
 20064fc:	c2 04 e0 10 	ld  [ %l3 + 0x10 ], %g1                        
  {                                                                   
    char queues[5];                                                   
    rtems_fdisk_queue_status (fd, sc, queues);                        
 2006500:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2006504:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
 2006508:	7f ff f9 e5 	call  2004c9c <rtems_fdisk_queue_status>       <== NOT EXECUTED
 200650c:	94 07 bf f8 	add  %fp, -8, %o2                              <== NOT EXECUTED
    rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",    
 2006510:	d6 04 e0 08 	ld  [ %l3 + 8 ], %o3                           <== NOT EXECUTED
 2006514:	d8 04 e0 0c 	ld  [ %l3 + 0xc ], %o4                         <== NOT EXECUTED
 2006518:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     <== NOT EXECUTED
 200651c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2006520:	92 12 63 68 	or  %o1, 0x368, %o1                            <== NOT EXECUTED
 2006524:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
 2006528:	7f ff fa 29 	call  2004dcc <rtems_fdisk_info>               <== NOT EXECUTED
 200652c:	9a 07 bf f8 	add  %fp, -8, %o5                              <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Find the next avaliable page in the segment.                     
   */                                                                 
                                                                      
  pd = sc->page_descriptors;                                          
 2006530:	c2 04 e0 10 	ld  [ %l3 + 0x10 ], %g1                        <== NOT EXECUTED
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
 2006534:	c4 04 e0 14 	ld  [ %l3 + 0x14 ], %g2                        
 2006538:	10 80 00 79 	b  200671c <rtems_fdisk_ioctl+0x974>           
 200653c:	b8 10 20 00 	clr  %i4                                       
  {                                                                   
    if (rtems_fdisk_page_desc_erased (pd))                            
 2006540:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
 2006544:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         
 2006548:	7f ff f9 fd 	call  2004d3c <rtems_fdisk_page_desc_erased>   
 200654c:	90 10 00 14 	mov  %l4, %o0                                  
 2006550:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 2006554:	80 8a 20 ff 	btst  0xff, %o0                                
 2006558:	02 80 00 70 	be  2006718 <rtems_fdisk_ioctl+0x970>          
 200655c:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
 2006560:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     
                                                                      
  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); 
 2006564:	c8 07 60 14 	ld  [ %i5 + 0x14 ], %g4                        
{                                                                     
  uint16_t cs = 0xffff;                                               
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
 2006568:	de 00 60 88 	ld  [ %g1 + 0x88 ], %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++)                           
 200656c:	86 10 20 00 	clr  %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;                                               
 2006570:	10 80 00 07 	b  200658c <rtems_fdisk_ioctl+0x7e4>           
 2006574:	82 10 3f ff 	mov  -1, %g1                                   
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
 2006578:	82 08 60 ff 	and  %g1, 0xff, %g1                            
 200657c:	82 18 40 0d 	xor  %g1, %o5, %g1                             
 2006580:	83 28 60 01 	sll  %g1, 1, %g1                               
 2006584:	c2 13 c0 01 	lduh  [ %o7 + %g1 ], %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++)                           
 2006588:	86 00 e0 01 	inc  %g3                                       
 200658c:	80 a0 c0 04 	cmp  %g3, %g4                                  
 2006590:	32 bf ff fa 	bne,a   2006578 <rtems_fdisk_ioctl+0x7d0>      
 2006594:	da 0c 40 03 	ldub  [ %l1 + %g3 ], %o5                       
                                                                      
  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); 
 2006598:	c2 35 00 00 	sth  %g1, [ %l4 ]                              
      pd->block = block;                                              
 200659c:	f2 25 20 04 	st  %i1, [ %l4 + 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;                                                
 20065a0:	c6 15 20 02 	lduh  [ %l4 + 2 ], %g3                         
    if (rtems_fdisk_page_desc_erased (pd))                            
    {                                                                 
      pd->crc   = rtems_fdisk_page_checksum (buffer, fd->block_size); 
      pd->block = block;                                              
                                                                      
      bc->segment = sc;                                               
 20065a4:	e6 25 c0 16 	st  %l3, [ %l7 + %l6 ]                         
      bc->page    = page;                                             
 20065a8:	f8 26 20 04 	st  %i4, [ %i0 + 4 ]                           
                                                                      
      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: " \    
 20065ac:	c8 04 c0 00 	ld  [ %l3 ], %g4                               
 * 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;                                                
 20065b0:	86 08 ff fe 	and  %g3, -2, %g3                              
 20065b4:	c6 35 20 02 	sth  %g3, [ %l4 + 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: " \    
 20065b8:	d6 04 e0 08 	ld  [ %l3 + 8 ], %o3                           
 20065bc:	d8 04 e0 0c 	ld  [ %l3 + 0xc ], %o4                         
 20065c0:	d4 04 e0 1c 	ld  [ %l3 + 0x1c ], %o2                        
 20065c4:	da 04 e0 20 	ld  [ %l3 + 0x20 ], %o5                        
 20065c8:	80 a1 20 00 	cmp  %g4, 0                                    
 20065cc:	02 80 00 05 	be  20065e0 <rtems_fdisk_ioctl+0x838>          <== ALWAYS TAKEN
 20065d0:	de 04 e0 24 	ld  [ %l3 + 0x24 ], %o7                        
 20065d4:	09 00 80 c3 	sethi  %hi(0x2030c00), %g4                     <== NOT EXECUTED
 20065d8:	10 80 00 04 	b  20065e8 <rtems_fdisk_ioctl+0x840>           <== NOT EXECUTED
 20065dc:	88 11 20 18 	or  %g4, 0x18, %g4	! 2030c18 <__FUNCTION__.7127+0x540><== NOT EXECUTED
 20065e0:	09 00 80 c3 	sethi  %hi(0x2030c00), %g4                     
 20065e4:	88 11 20 20 	or  %g4, 0x20, %g4	! 2030c20 <__FUNCTION__.7127+0x548>
 20065e8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 20065ec:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 20065f0:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
 20065f4:	83 30 60 10 	srl  %g1, 0x10, %g1                            
 20065f8:	c4 23 a0 5c 	st  %g2, [ %sp + 0x5c ]                        
 20065fc:	d4 23 a0 60 	st  %o2, [ %sp + 0x60 ]                        
 2006600:	da 23 a0 64 	st  %o5, [ %sp + 0x64 ]                        
 2006604:	94 10 00 19 	mov  %i1, %o2                                  
 2006608:	de 23 a0 68 	st  %o7, [ %sp + 0x68 ]                        
 200660c:	c8 23 a0 6c 	st  %g4, [ %sp + 0x6c ]                        
 2006610:	c6 23 a0 70 	st  %g3, [ %sp + 0x70 ]                        
 2006614:	c2 23 a0 74 	st  %g1, [ %sp + 0x74 ]                        
 2006618:	f2 23 a0 78 	st  %i1, [ %sp + 0x78 ]                        
 200661c:	9a 10 00 1c 	mov  %i4, %o5                                  
 2006620:	90 10 00 1d 	mov  %i5, %o0                                  
 2006624:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     
 2006628:	7f ff f9 e9 	call  2004dcc <rtems_fdisk_info>               
 200662c:	92 12 63 90 	or  %o1, 0x390, %o1	! 2031390 <__FUNCTION__.7127+0xcb8>
                                                                      
      /*                                                              
       * 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);
 2006630:	d4 04 e0 18 	ld  [ %l3 + 0x18 ], %o2                        
 2006634:	90 10 00 1d 	mov  %i5, %o0                                  
 2006638:	92 10 00 13 	mov  %l3, %o1                                  
 200663c:	94 07 00 0a 	add  %i4, %o2, %o2                             
 2006640:	7f ff fc 50 	call  2005780 <rtems_fdisk_seg_write_page>     
 2006644:	96 10 00 11 	mov  %l1, %o3                                  
      if (ret)                                                        
 2006648:	b2 92 20 00 	orcc  %o0, 0, %i1                              
 200664c:	22 80 00 0d 	be,a   2006680 <rtems_fdisk_ioctl+0x8d8>       <== ALWAYS TAKEN
 2006650:	90 10 00 1d 	mov  %i5, %o0                                  
      {                                                               
#if RTEMS_FDISK_TRACE                                                 
        rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
 2006654:	e8 04 e0 08 	ld  [ %l3 + 8 ], %l4                           <== NOT EXECUTED
 2006658:	40 00 72 b7 	call  2023134 <strerror>                       <== NOT EXECUTED
 200665c:	f0 04 e0 0c 	ld  [ %l3 + 0xc ], %i0                         <== NOT EXECUTED
 2006660:	13 00 80 c4 	sethi  %hi(0x2031000), %o1                     <== NOT EXECUTED
 2006664:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
 2006668:	f2 23 a0 5c 	st  %i1, [ %sp + 0x5c ]                        <== NOT EXECUTED
 200666c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2006670:	92 12 63 e0 	or  %o1, 0x3e0, %o1                            <== NOT EXECUTED
 2006674:	94 10 00 14 	mov  %l4, %o2                                  <== NOT EXECUTED
 2006678:	10 80 00 14 	b  20066c8 <rtems_fdisk_ioctl+0x920>           <== NOT EXECUTED
 200667c:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
                          strerror (ret), ret);                       
#endif                                                                
      }                                                               
      else                                                            
      {                                                               
        ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);     
 2006680:	92 10 00 13 	mov  %l3, %o1                                  
 2006684:	94 10 00 1c 	mov  %i4, %o2                                  
 2006688:	7f ff fb 54 	call  20053d8 <rtems_fdisk_seg_write_page_desc>
 200668c:	96 10 00 14 	mov  %l4, %o3                                  
        if (ret)                                                      
 2006690:	b2 92 20 00 	orcc  %o0, 0, %i1                              
 2006694:	22 80 00 11 	be,a   20066d8 <rtems_fdisk_ioctl+0x930>       <== ALWAYS TAKEN
 2006698:	c2 04 e0 1c 	ld  [ %l3 + 0x1c ], %g1                        
        {                                                             
#if RTEMS_FDISK_TRACE                                                 
          rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: "  \     
 200669c:	ec 04 e0 08 	ld  [ %l3 + 8 ], %l6                           <== NOT EXECUTED
 20066a0:	e8 04 e0 0c 	ld  [ %l3 + 0xc ], %l4                         <== NOT EXECUTED
 20066a4:	40 00 72 a4 	call  2023134 <strerror>                       <== NOT EXECUTED
 20066a8:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           <== NOT EXECUTED
 20066ac:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     <== NOT EXECUTED
 20066b0:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
 20066b4:	f2 23 a0 5c 	st  %i1, [ %sp + 0x5c ]                        <== NOT EXECUTED
 20066b8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20066bc:	92 12 60 18 	or  %o1, 0x18, %o1                             <== NOT EXECUTED
 20066c0:	94 10 00 16 	mov  %l6, %o2                                  <== NOT EXECUTED
 20066c4:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
 20066c8:	7f ff f9 c1 	call  2004dcc <rtems_fdisk_info>               <== NOT EXECUTED
 20066cc:	98 10 00 1c 	mov  %i4, %o4                                  <== NOT EXECUTED
        {                                                             
          sc->pages_active++;                                         
        }                                                             
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
 20066d0:	10 80 00 05 	b  20066e4 <rtems_fdisk_ioctl+0x93c>           <== NOT EXECUTED
 20066d4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                            strerror (ret), ret);                     
#endif                                                                
        }                                                             
        else                                                          
        {                                                             
          sc->pages_active++;                                         
 20066d8:	82 00 60 01 	inc  %g1                                       
 20066dc:	c2 24 e0 1c 	st  %g1, [ %l3 + 0x1c ]                        
        }                                                             
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
 20066e0:	90 10 00 1d 	mov  %i5, %o0                                  
 20066e4:	7f ff fa 77 	call  20050c0 <rtems_fdisk_queue_segment>      
 20066e8:	92 10 00 13 	mov  %l3, %o1                                  
static bool                                                           
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
 20066ec:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
 20066f0:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 20066f4:	80 a0 80 01 	cmp  %g2, %g1                                  
 20066f8:	1a 80 00 19 	bcc  200675c <rtems_fdisk_ioctl+0x9b4>         
 20066fc:	90 10 00 1d 	mov  %i5, %o0                                  
    fd->starvations++;                                                
 2006700:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
 2006704:	82 00 60 01 	inc  %g1                                       
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
                                                                      
      if (rtems_fdisk_is_erased_blocks_starvation (fd))               
        rtems_fdisk_compact (fd);                                     
 2006708:	7f ff fd 1a 	call  2005b70 <rtems_fdisk_compact>            
 200670c:	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)                                                        
 2006710:	10 80 00 14 	b  2006760 <rtems_fdisk_ioctl+0x9b8>           
 2006714:	80 a6 60 00 	cmp  %i1, 0                                    
   * Find the next avaliable page in the segment.                     
   */                                                                 
                                                                      
  pd = sc->page_descriptors;                                          
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
 2006718:	b8 07 20 01 	inc  %i4                                       
 * @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)   
 200671c:	a9 2f 20 03 	sll  %i4, 3, %l4                               
   * Find the next avaliable page in the segment.                     
   */                                                                 
                                                                      
  pd = sc->page_descriptors;                                          
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
 2006720:	80 a7 00 02 	cmp  %i4, %g2                                  
 2006724:	12 bf ff 87 	bne  2006540 <rtems_fdisk_ioctl+0x798>         <== ALWAYS TAKEN
 2006728:	a8 00 40 14 	add  %g1, %l4, %l4                             
                                                                      
      return ret;                                                     
    }                                                                 
  }                                                                   
                                                                      
  rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
 200672c:	d2 04 e0 08 	ld  [ %l3 + 8 ], %o1                           <== NOT EXECUTED
 2006730:	d4 04 e0 0c 	ld  [ %l3 + 0xc ], %o2                         <== NOT EXECUTED
 2006734:	11 00 80 c5 	sethi  %hi(0x2031400), %o0                     <== NOT EXECUTED
 2006738:	7f ff fa 05 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 200673c:	90 12 20 58 	or  %o0, 0x58, %o0	! 2031458 <__FUNCTION__.7127+0xd80><== NOT EXECUTED
                     sc->device, sc->segment);                        
                                                                      
  sc->failed = true;                                                  
 2006740:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
  rtems_fdisk_queue_segment (fd, sc);                                 
 2006744:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
                     sc->device, sc->segment);                        
                                                                      
  sc->failed = true;                                                  
 2006748:	c2 24 e0 28 	st  %g1, [ %l3 + 0x28 ]                        <== NOT EXECUTED
  rtems_fdisk_queue_segment (fd, sc);                                 
 200674c:	7f ff fa 5d 	call  20050c0 <rtems_fdisk_queue_segment>      <== NOT EXECUTED
 2006750:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
                                                                      
  return EIO;                                                         
 2006754:	10 80 00 0d 	b  2006788 <rtems_fdisk_ioctl+0x9e0>           <== NOT EXECUTED
 2006758:	b2 10 20 05 	mov  5, %i1                                    <== NOT EXECUTED
    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)                                                        
 200675c:	80 a6 60 00 	cmp  %i1, 0                                    
 2006760:	32 80 00 0b 	bne,a   200678c <rtems_fdisk_ioctl+0x9e4>      <== NEVER TAKEN
 2006764:	aa 05 60 01 	inc  %l5                                       <== 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)                  
 2006768:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 200676c:	a4 04 a0 01 	inc  %l2                                       
 2006770:	a2 04 40 01 	add  %l1, %g1, %l1                             
 2006774:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 2006778:	80 a4 80 01 	cmp  %l2, %g1                                  
 200677c:	32 bf fe 93 	bne,a   20061c8 <rtems_fdisk_ioctl+0x420>      
 2006780:	f2 04 00 00 	ld  [ %l0 ], %i1                               
 2006784:	b2 10 20 00 	clr  %i1                                       
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
 2006788:	aa 05 60 01 	inc  %l5                                       
 200678c:	80 a6 60 00 	cmp  %i1, 0                                    
 2006790:	12 80 00 08 	bne  20067b0 <rtems_fdisk_ioctl+0xa08>         <== NEVER TAKEN
 2006794:	a0 04 20 10 	add  %l0, 0x10, %l0                            
 2006798:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
 200679c:	80 a5 40 01 	cmp  %l5, %g1                                  
 20067a0:	2a bf fe 84 	bcs,a   20061b0 <rtems_fdisk_ioctl+0x408>      
 20067a4:	d0 04 20 04 	ld  [ %l0 + 4 ], %o0                           
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
 20067a8:	10 80 00 03 	b  20067b4 <rtems_fdisk_ioctl+0xa0c>           
 20067ac:	92 10 20 00 	clr  %o1                                       
 20067b0:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
 20067b4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
 20067b8:	9f c0 40 00 	call  %g1                                      
 20067bc:	90 10 00 1a 	mov  %i2, %o0                                  
            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);
 20067c0:	10 80 01 c0 	b  2006ec0 <rtems_fdisk_ioctl+0x1118>          
 20067c4:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2                         
              break;                                                  
                                                                      
            default:                                                  
              errno = EINVAL;                                         
 20067c8:	40 00 68 96 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20067cc:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20067d0:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
              break;                                                  
 20067d4:	10 80 01 c0 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          <== NOT EXECUTED
 20067d8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
          }                                                           
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_DISK:                              
        errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);    
 20067dc:	40 00 68 91 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20067e0:	21 00 80 c5 	sethi  %hi(0x2031400), %l0                     <== NOT EXECUTED
 20067e4:	fa 07 60 80 	ld  [ %i5 + 0x80 ], %i5                        <== NOT EXECUTED
 20067e8:	b2 10 00 08 	mov  %o0, %i1                                  <== NOT EXECUTED
 20067ec:	ba 07 40 1b 	add  %i5, %i3, %i5                             <== NOT EXECUTED
{                                                                     
  uint32_t device;                                                    
  int      ret;                                                       
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd, "erase-disk");                                
 20067f0:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     <== NOT EXECUTED
 20067f4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20067f8:	92 12 60 90 	or  %o1, 0x90, %o1                             <== NOT EXECUTED
 20067fc:	7f ff f9 74 	call  2004dcc <rtems_fdisk_info>               <== NOT EXECUTED
 2006800:	31 00 80 c5 	sethi  %hi(0x2031400), %i0                     <== NOT EXECUTED
 2006804:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
 2006808:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  {                                                                   
    int ret;                                                          
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
 200680c:	a0 14 20 a0 	or  %l0, 0xa0, %l0                             <== 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);             
 2006810:	10 80 00 17 	b  200686c <rtems_fdisk_ioctl+0xac4>           <== NOT EXECUTED
 2006814:	b0 16 20 b8 	or  %i0, 0xb8, %i0                             <== NOT EXECUTED
  for (device = 0; device < fd->device_count; device++)               
  {                                                                   
    int ret;                                                          
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
 2006818:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 200681c:	7f ff f9 6c 	call  2004dcc <rtems_fdisk_info>               <== NOT EXECUTED
 2006820:	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;                    
 2006824:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
 2006828:	92 10 00 18 	mov  %i0, %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;                    
 200682c:	82 00 40 1a 	add  %g1, %i2, %g1                             <== NOT EXECUTED
 2006830:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
 2006834:	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;                    
 2006838:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
 200683c:	7f ff f9 84 	call  2004e4c <rtems_fdisk_printf>             <== NOT EXECUTED
 2006840:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
#endif                                                                
  return ops->erase_device (fd->devices[device].descriptor, device);  
 2006844:	c4 07 60 2c 	ld  [ %i5 + 0x2c ], %g2                        <== NOT EXECUTED
 2006848:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        <== NOT EXECUTED
 200684c:	84 00 80 1a 	add  %g2, %i2, %g2                             <== NOT EXECUTED
 2006850:	d0 00 a0 08 	ld  [ %g2 + 8 ], %o0                           <== NOT EXECUTED
 2006854:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 2006858:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 200685c:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             <== NOT EXECUTED
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
#endif                                                                
                                                                      
    ret = rtems_fdisk_device_erase (fd, device);                      
                                                                      
    if (ret != 0)                                                     
 2006860:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2006864:	12 80 00 18 	bne  20068c4 <rtems_fdisk_ioctl+0xb1c>         <== NOT EXECUTED
 2006868:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
 200686c:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
 2006870:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
 2006874:	0a bf ff e9 	bcs  2006818 <rtems_fdisk_ioctl+0xa70>         <== NOT EXECUTED
 2006878:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 200687c:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
 2006880:	10 80 00 0d 	b  20068b4 <rtems_fdisk_ioctl+0xb0c>           <== NOT EXECUTED
 2006884:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
                                                                      
  if (ret == 0)                                                       
  {                                                                   
    for (device = 0; device < fd->device_count; device++)             
    {                                                                 
      if (!fd->devices[device].segments)                              
 2006888:	c2 00 40 1a 	ld  [ %g1 + %i2 ], %g1                         <== NOT EXECUTED
 200688c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2006890:	02 80 00 0d 	be  20068c4 <rtems_fdisk_ioctl+0xb1c>          <== NOT EXECUTED
 2006894:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
        return ENOMEM;                                                
                                                                      
      ret = rtems_fdisk_recover_block_mappings (fd);                  
 2006898:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 200689c:	7f ff fa e0 	call  200541c <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
 20068a0:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             <== NOT EXECUTED
      if (ret)                                                        
 20068a4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 20068a8:	12 80 00 07 	bne  20068c4 <rtems_fdisk_ioctl+0xb1c>         <== NOT EXECUTED
 20068ac:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
                                                                      
  ret = rtems_fdisk_erase_flash (fd);                                 
                                                                      
  if (ret == 0)                                                       
  {                                                                   
    for (device = 0; device < fd->device_count; device++)             
 20068b0:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
 20068b4:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
 20068b8:	2a bf ff f4 	bcs,a   2006888 <rtems_fdisk_ioctl+0xae0>      <== NOT EXECUTED
 20068bc:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
 20068c0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_DISK:                              
        errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);    
        break;                                                        
 20068c4:	10 80 01 84 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          <== NOT EXECUTED
 20068c8:	d0 26 40 00 	st  %o0, [ %i1 ]                               <== NOT EXECUTED
                                                                      
      case RTEMS_FDISK_IOCTL_COMPACT:                                 
        errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);       
 20068cc:	40 00 68 55 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20068d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20068d4:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
 20068d8:	d0 07 60 80 	ld  [ %i5 + 0x80 ], %o0                        <== NOT EXECUTED
 20068dc:	7f ff fc a5 	call  2005b70 <rtems_fdisk_compact>            <== NOT EXECUTED
 20068e0:	90 02 00 1b 	add  %o0, %i3, %o0                             <== NOT EXECUTED
        break;                                                        
 20068e4:	10 80 01 7c 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          <== NOT EXECUTED
 20068e8:	d0 27 00 00 	st  %o0, [ %i4 ]                               <== NOT EXECUTED
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_USED:                              
        errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);    
 20068ec:	40 00 68 4d 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20068f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20068f4:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
 20068f8:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
 20068fc:	b8 07 00 1b 	add  %i4, %i3, %i4                             <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_used (rtems_flashdisk* fd)                          
{                                                                     
  rtems_fdisk_segment_ctl* sc;                                        
  int                      latched_ret = 0;                           
 2006900:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      
  while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))      
 2006904:	10 80 00 09 	b  2006928 <rtems_fdisk_ioctl+0xb80>           <== NOT EXECUTED
 2006908:	b2 07 20 4c 	add  %i4, 0x4c, %i1                            <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The segment will either end up on the available queue or       
     * the failed queue.                                              
     */                                                               
    int ret = rtems_fdisk_erase_segment (fd, sc);                     
 200690c:	7f ff f9 ad 	call  2004fc0 <rtems_fdisk_erase_segment>      <== NOT EXECUTED
 2006910:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    if (ret && !latched_ret)                                          
 2006914:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2006918:	02 80 00 04 	be  2006928 <rtems_fdisk_ioctl+0xb80>          <== NOT EXECUTED
 200691c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
 2006920:	22 80 00 02 	be,a   2006928 <rtems_fdisk_ioctl+0xb80>       <== NOT EXECUTED
 2006924:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
rtems_fdisk_erase_used (rtems_flashdisk* fd)                          
{                                                                     
  rtems_fdisk_segment_ctl* sc;                                        
  int                      latched_ret = 0;                           
                                                                      
  while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))      
 2006928:	7f ff f8 75 	call  2004afc <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
 200692c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 2006930:	92 92 20 00 	orcc  %o0, 0, %o1                              <== NOT EXECUTED
 2006934:	12 bf ff f6 	bne  200690c <rtems_fdisk_ioctl+0xb64>         <== NOT EXECUTED
 2006938:	01 00 00 00 	nop                                            <== NOT EXECUTED
        errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);       
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_USED:                              
        errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);    
        break;                                                        
 200693c:	10 80 01 66 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          <== NOT EXECUTED
 2006940:	fa 26 80 00 	st  %i5, [ %i2 ]                               <== NOT EXECUTED
                                                                      
      case RTEMS_FDISK_IOCTL_MONITORING:                              
        errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
 2006944:	40 00 68 37 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2006948:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200694c:	fa 07 60 80 	ld  [ %i5 + 0x80 ], %i5                        <== NOT EXECUTED
 2006950:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
 2006954:	ba 07 40 1b 	add  %i5, %i3, %i5                             <== NOT EXECUTED
                             rtems_fdisk_monitor_data* data)          
{                                                                     
  uint32_t i;                                                         
  uint32_t j;                                                         
                                                                      
  data->block_size     = fd->block_size;                              
 2006958:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
 200695c:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        <== NOT EXECUTED
  data->unavail_blocks = fd->unavail_blocks;                          
  data->device_count   = fd->device_count;                            
 2006960:	f2 07 60 30 	ld  [ %i5 + 0x30 ], %i1                        <== NOT EXECUTED
                             rtems_fdisk_monitor_data* data)          
{                                                                     
  uint32_t i;                                                         
  uint32_t j;                                                         
                                                                      
  data->block_size     = fd->block_size;                              
 2006964:	c2 26 80 00 	st  %g1, [ %i2 ]                               <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
  data->unavail_blocks = fd->unavail_blocks;                          
 2006968:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        <== NOT EXECUTED
{                                                                     
  uint32_t i;                                                         
  uint32_t j;                                                         
                                                                      
  data->block_size     = fd->block_size;                              
  data->block_count    = fd->block_count;                             
 200696c:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]                           <== NOT EXECUTED
  data->unavail_blocks = fd->unavail_blocks;                          
 2006970:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           <== NOT EXECUTED
  data->device_count   = fd->device_count;                            
 2006974:	f2 26 a0 0c 	st  %i1, [ %i2 + 0xc ]                         <== NOT EXECUTED
                                                                      
  data->blocks_used = 0;                                              
 2006978:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            <== NOT EXECUTED
  for (i = 0; i < fd->block_count; i++)                               
 200697c:	10 80 00 0a 	b  20069a4 <rtems_fdisk_ioctl+0xbfc>           <== NOT EXECUTED
 2006980:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
    if (fd->blocks[i].segment)                                        
 2006984:	87 28 60 03 	sll  %g1, 3, %g3                               <== NOT EXECUTED
 2006988:	c6 01 00 03 	ld  [ %g4 + %g3 ], %g3                         <== NOT EXECUTED
 200698c:	80 a0 e0 00 	cmp  %g3, 0                                    <== NOT EXECUTED
 2006990:	02 80 00 05 	be  20069a4 <rtems_fdisk_ioctl+0xbfc>          <== NOT EXECUTED
 2006994:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
      data->blocks_used++;                                            
 2006998:	c6 06 a0 18 	ld  [ %i2 + 0x18 ], %g3                        <== NOT EXECUTED
 200699c:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
 20069a0:	c6 26 a0 18 	st  %g3, [ %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++)                               
 20069a4:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 20069a8:	32 bf ff f7 	bne,a   2006984 <rtems_fdisk_ioctl+0xbdc>      <== NOT EXECUTED
 20069ac:	c8 07 60 18 	ld  [ %i5 + 0x18 ], %g4                        <== NOT EXECUTED
    if (fd->blocks[i].segment)                                        
      data->blocks_used++;                                            
                                                                      
  data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
 20069b0:	7f ff f8 a7 	call  2004c4c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
 20069b4:	90 07 60 34 	add  %i5, 0x34, %o0                            <== NOT EXECUTED
 20069b8:	d0 26 a0 1c 	st  %o0, [ %i2 + 0x1c ]                        <== NOT EXECUTED
  data->segs_used      = rtems_fdisk_segment_count_queue (&fd->used); 
 20069bc:	7f ff f8 a4 	call  2004c4c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
 20069c0:	90 07 60 40 	add  %i5, 0x40, %o0                            <== NOT EXECUTED
 20069c4:	d0 26 a0 20 	st  %o0, [ %i2 + 0x20 ]                        <== NOT EXECUTED
  data->segs_failed    = rtems_fdisk_segment_count_queue (&fd->failed);
 20069c8:	7f ff f8 a1 	call  2004c4c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
 20069cc:	90 07 60 58 	add  %i5, 0x58, %o0                            <== NOT EXECUTED
  data->page_count    = 0;                                            
  data->pages_desc    = 0;                                            
  data->pages_active  = 0;                                            
  data->pages_used    = 0;                                            
  data->pages_bad     = 0;                                            
  data->seg_erases    = 0;                                            
 20069d0:	86 10 20 00 	clr  %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);
 20069d4:	d0 26 a0 24 	st  %o0, [ %i2 + 0x24 ]                        <== NOT EXECUTED
                                                                      
  data->segment_count = 0;                                            
 20069d8:	c0 26 a0 10 	clr  [ %i2 + 0x10 ]                            <== NOT EXECUTED
  data->page_count    = 0;                                            
 20069dc:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            <== NOT EXECUTED
  data->pages_desc    = 0;                                            
 20069e0:	c0 26 a0 2c 	clr  [ %i2 + 0x2c ]                            <== NOT EXECUTED
  data->pages_active  = 0;                                            
 20069e4:	c0 26 a0 30 	clr  [ %i2 + 0x30 ]                            <== NOT EXECUTED
  data->pages_used    = 0;                                            
 20069e8:	c0 26 a0 34 	clr  [ %i2 + 0x34 ]                            <== NOT EXECUTED
  data->pages_bad     = 0;                                            
 20069ec:	c0 26 a0 38 	clr  [ %i2 + 0x38 ]                            <== NOT EXECUTED
  data->seg_erases    = 0;                                            
 20069f0:	c0 26 a0 28 	clr  [ %i2 + 0x28 ]                            <== NOT EXECUTED
                                                                      
  for (i = 0; i < fd->device_count; i++)                              
 20069f4:	10 80 00 2a 	b  2006a9c <rtems_fdisk_ioctl+0xcf4>           <== NOT EXECUTED
 20069f8:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
  {                                                                   
    data->segment_count += fd->devices[i].segment_count;              
 20069fc:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        <== NOT EXECUTED
 2006a00:	9e 03 c0 03 	add  %o7, %g3, %o7                             <== NOT EXECUTED
 2006a04:	f0 03 e0 04 	ld  [ %o7 + 4 ], %i0                           <== NOT EXECUTED
 2006a08:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
 2006a0c:	82 00 40 18 	add  %g1, %i0, %g1                             <== NOT EXECUTED
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
 2006a10:	88 10 20 00 	clr  %g4                                       <== 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;              
 2006a14:	10 80 00 1d 	b  2006a88 <rtems_fdisk_ioctl+0xce0>           <== NOT EXECUTED
 2006a18:	c2 26 a0 10 	st  %g1, [ %i2 + 0x10 ]                        <== 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;                                
 2006a1c:	d8 06 a0 14 	ld  [ %i2 + 0x14 ], %o4                        <== NOT EXECUTED
  {                                                                   
    data->segment_count += fd->devices[i].segment_count;              
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];      
 2006a20:	82 00 40 1c 	add  %g1, %i4, %g1                             <== NOT EXECUTED
                                                                      
      data->page_count   += sc->pages;                                
 2006a24:	da 00 60 14 	ld  [ %g1 + 0x14 ], %o5                        <== 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++)                
 2006a28:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];      
                                                                      
      data->page_count   += sc->pages;                                
 2006a2c:	9a 03 00 0d 	add  %o4, %o5, %o5                             <== NOT EXECUTED
      data->pages_desc   += sc->pages_desc;                           
 2006a30:	d8 06 a0 2c 	ld  [ %i2 + 0x2c ], %o4                        <== 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;                                
 2006a34:	da 26 a0 14 	st  %o5, [ %i2 + 0x14 ]                        <== NOT EXECUTED
      data->pages_desc   += sc->pages_desc;                           
 2006a38:	da 00 60 18 	ld  [ %g1 + 0x18 ], %o5                        <== NOT EXECUTED
 2006a3c:	b8 07 20 30 	add  %i4, 0x30, %i4                            <== NOT EXECUTED
 2006a40:	9a 03 00 0d 	add  %o4, %o5, %o5                             <== NOT EXECUTED
      data->pages_active += sc->pages_active;                         
 2006a44:	d8 06 a0 30 	ld  [ %i2 + 0x30 ], %o4                        <== 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;                                
      data->pages_desc   += sc->pages_desc;                           
 2006a48:	da 26 a0 2c 	st  %o5, [ %i2 + 0x2c ]                        <== NOT EXECUTED
      data->pages_active += sc->pages_active;                         
 2006a4c:	da 00 60 1c 	ld  [ %g1 + 0x1c ], %o5                        <== NOT EXECUTED
 2006a50:	9a 03 00 0d 	add  %o4, %o5, %o5                             <== NOT EXECUTED
      data->pages_used   += sc->pages_used;                           
 2006a54:	d8 06 a0 34 	ld  [ %i2 + 0x34 ], %o4                        <== NOT EXECUTED
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];      
                                                                      
      data->page_count   += sc->pages;                                
      data->pages_desc   += sc->pages_desc;                           
      data->pages_active += sc->pages_active;                         
 2006a58:	da 26 a0 30 	st  %o5, [ %i2 + 0x30 ]                        <== NOT EXECUTED
      data->pages_used   += sc->pages_used;                           
 2006a5c:	da 00 60 20 	ld  [ %g1 + 0x20 ], %o5                        <== NOT EXECUTED
 2006a60:	9a 03 00 0d 	add  %o4, %o5, %o5                             <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
 2006a64:	d8 06 a0 38 	ld  [ %i2 + 0x38 ], %o4                        <== NOT EXECUTED
      rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];      
                                                                      
      data->page_count   += sc->pages;                                
      data->pages_desc   += sc->pages_desc;                           
      data->pages_active += sc->pages_active;                         
      data->pages_used   += sc->pages_used;                           
 2006a68:	da 26 a0 34 	st  %o5, [ %i2 + 0x34 ]                        <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
 2006a6c:	da 00 60 24 	ld  [ %g1 + 0x24 ], %o5                        <== NOT EXECUTED
      data->seg_erases   += sc->erased;                               
 2006a70:	c2 00 60 2c 	ld  [ %g1 + 0x2c ], %g1                        <== NOT EXECUTED
                                                                      
      data->page_count   += sc->pages;                                
      data->pages_desc   += sc->pages_desc;                           
      data->pages_active += sc->pages_active;                         
      data->pages_used   += sc->pages_used;                           
      data->pages_bad    += sc->pages_bad;                            
 2006a74:	9a 03 00 0d 	add  %o4, %o5, %o5                             <== NOT EXECUTED
 2006a78:	da 26 a0 38 	st  %o5, [ %i2 + 0x38 ]                        <== NOT EXECUTED
      data->seg_erases   += sc->erased;                               
 2006a7c:	da 06 a0 28 	ld  [ %i2 + 0x28 ], %o5                        <== NOT EXECUTED
 2006a80:	82 03 40 01 	add  %o5, %g1, %g1                             <== NOT EXECUTED
 2006a84:	c2 26 a0 28 	st  %g1, [ %i2 + 0x28 ]                        <== 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++)                
 2006a88:	80 a1 00 18 	cmp  %g4, %i0                                  <== NOT EXECUTED
 2006a8c:	32 bf ff e4 	bne,a   2006a1c <rtems_fdisk_ioctl+0xc74>      <== NOT EXECUTED
 2006a90:	c2 03 c0 00 	ld  [ %o7 ], %g1                               <== 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++)                              
 2006a94:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
 2006a98:	86 00 e0 0c 	add  %g3, 0xc, %g3                             <== NOT EXECUTED
 2006a9c:	80 a0 80 19 	cmp  %g2, %i1                                  <== NOT EXECUTED
 2006aa0:	32 bf ff d7 	bne,a   20069fc <rtems_fdisk_ioctl+0xc54>      <== NOT EXECUTED
 2006aa4:	de 07 60 2c 	ld  [ %i5 + 0x2c ], %o7                        <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
      data->seg_erases   += sc->erased;                               
    }                                                                 
  }                                                                   
                                                                      
  data->info_level = fd->info_level;                                  
 2006aa8:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        <== NOT EXECUTED
 2006aac:	c2 26 a0 3c 	st  %g1, [ %i2 + 0x3c ]                        <== NOT EXECUTED
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_MONITORING:                              
        errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
                                             (rtems_fdisk_monitor_data*) argp);
        break;                                                        
 2006ab0:	10 80 01 09 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          <== NOT EXECUTED
 2006ab4:	c0 24 00 00 	clr  [ %l0 ]                                   <== NOT EXECUTED
                                                                      
      case RTEMS_FDISK_IOCTL_INFO_LEVEL:                              
        rtems_flashdisks[minor].info_level = (uintptr_t) argp;        
 2006ab8:	82 00 40 1b 	add  %g1, %i3, %g1                             <== NOT EXECUTED
        break;                                                        
 2006abc:	10 80 01 06 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          <== NOT EXECUTED
 2006ac0:	f4 20 60 6c 	st  %i2, [ %g1 + 0x6c ]                        <== NOT EXECUTED
                                                                      
      case RTEMS_FDISK_IOCTL_PRINT_STATUS:                            
        errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);  
 2006ac4:	40 00 67 d7 	call  2020a20 <__errno>                        
 2006ac8:	01 00 00 00 	nop                                            
 2006acc:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 2006ad0:	d0 27 bf ec 	st  %o0, [ %fp + -20 ]                         
 2006ad4:	ba 00 40 1b 	add  %g1, %i3, %i5                             
 */                                                                   
static int                                                            
rtems_fdisk_print_status (rtems_flashdisk* fd)                        
{                                                                     
#if RTEMS_FDISK_TRACE                                                 
  uint32_t current_info_level = fd->info_level;                       
 2006ad8:	c4 07 60 6c 	ld  [ %i5 + 0x6c ], %g2                        
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
                                                                      
  rtems_fdisk_printf (fd,                                             
 2006adc:	d4 00 40 1b 	ld  [ %g1 + %i3 ], %o2                         
 2006ae0:	d6 07 60 04 	ld  [ %i5 + 4 ], %o3                           
 */                                                                   
static int                                                            
rtems_fdisk_print_status (rtems_flashdisk* fd)                        
{                                                                     
#if RTEMS_FDISK_TRACE                                                 
  uint32_t current_info_level = fd->info_level;                       
 2006ae4:	c4 27 bf e8 	st  %g2, [ %fp + -24 ]                         
  uint32_t total;                                                     
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
 2006ae8:	84 10 20 03 	mov  3, %g2                                    
                                                                      
  rtems_fdisk_printf (fd,                                             
 2006aec:	90 10 00 1d 	mov  %i5, %o0                                  
  uint32_t current_info_level = fd->info_level;                       
  uint32_t total;                                                     
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
 2006af0:	c4 27 60 6c 	st  %g2, [ %i5 + 0x6c ]                        
                                                                      
  rtems_fdisk_printf (fd,                                             
 2006af4:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006af8:	7f ff f8 d5 	call  2004e4c <rtems_fdisk_printf>             
 2006afc:	92 12 60 d0 	or  %o1, 0xd0, %o1	! 20314d0 <__FUNCTION__.7127+0xdf8>
                      "Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
                                                                      
  rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);        
 2006b00:	d4 07 60 1c 	ld  [ %i5 + 0x1c ], %o2                        
 2006b04:	90 10 00 1d 	mov  %i5, %o0                                  
 2006b08:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006b0c:	7f ff f8 d0 	call  2004e4c <rtems_fdisk_printf>             
 2006b10:	92 12 60 f8 	or  %o1, 0xf8, %o1	! 20314f8 <__FUNCTION__.7127+0xe20>
  rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);  
 2006b14:	d4 07 60 20 	ld  [ %i5 + 0x20 ], %o2                        
 2006b18:	90 10 00 1d 	mov  %i5, %o0                                  
 2006b1c:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006b20:	7f ff f8 cb 	call  2004e4c <rtems_fdisk_printf>             
 2006b24:	92 12 61 08 	or  %o1, 0x108, %o1	! 2031508 <__FUNCTION__.7127+0xe30>
  rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
 2006b28:	d4 07 60 24 	ld  [ %i5 + 0x24 ], %o2                        
 2006b2c:	90 10 00 1d 	mov  %i5, %o0                                  
 2006b30:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006b34:	7f ff f8 c6 	call  2004e4c <rtems_fdisk_printf>             
 2006b38:	92 12 61 20 	or  %o1, 0x120, %o1	! 2031520 <__FUNCTION__.7127+0xe48>
  rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);        
 2006b3c:	d4 07 60 70 	ld  [ %i5 + 0x70 ], %o2                        
 2006b40:	90 10 00 1d 	mov  %i5, %o0                                  
 2006b44:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006b48:	7f ff f8 c1 	call  2004e4c <rtems_fdisk_printf>             
 2006b4c:	92 12 61 38 	or  %o1, 0x138, %o1	! 2031538 <__FUNCTION__.7127+0xe60>
  count = rtems_fdisk_segment_count_queue (&fd->available);           
 2006b50:	7f ff f8 3f 	call  2004c4c <rtems_fdisk_segment_count_queue>
 2006b54:	90 07 60 34 	add  %i5, 0x34, %o0                            
  total = count;                                                      
  rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",               
 2006b58:	d6 07 60 3c 	ld  [ %i5 + 0x3c ], %o3                        
                                                                      
  rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);        
  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);           
 2006b5c:	b8 10 00 08 	mov  %o0, %i4                                  
  total = count;                                                      
  rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",               
 2006b60:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006b64:	94 10 00 1c 	mov  %i4, %o2                                  
 2006b68:	92 12 61 48 	or  %o1, 0x148, %o1                            
 2006b6c:	7f ff f8 b8 	call  2004e4c <rtems_fdisk_printf>             
 2006b70:	90 10 00 1d 	mov  %i5, %o0                                  
                      count, rtems_fdisk_segment_queue_count (&fd->available));
  count = rtems_fdisk_segment_count_queue (&fd->used);                
 2006b74:	7f ff f8 36 	call  2004c4c <rtems_fdisk_segment_count_queue>
 2006b78:	90 07 60 40 	add  %i5, 0x40, %o0                            
  total += count;                                                     
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
 2006b7c:	d6 07 60 48 	ld  [ %i5 + 0x48 ], %o3                        
  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)",               
                      count, rtems_fdisk_segment_queue_count (&fd->available));
  count = rtems_fdisk_segment_count_queue (&fd->used);                
 2006b80:	94 10 00 08 	mov  %o0, %o2                                  
  total += count;                                                     
 2006b84:	b8 02 00 1c 	add  %o0, %i4, %i4                             
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
 2006b88:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006b8c:	90 10 00 1d 	mov  %i5, %o0                                  
 2006b90:	7f ff f8 af 	call  2004e4c <rtems_fdisk_printf>             
 2006b94:	92 12 61 68 	or  %o1, 0x168, %o1                            
                      count, rtems_fdisk_segment_queue_count (&fd->used));
  count = rtems_fdisk_segment_count_queue (&fd->erase);               
 2006b98:	7f ff f8 2d 	call  2004c4c <rtems_fdisk_segment_count_queue>
 2006b9c:	90 07 60 4c 	add  %i5, 0x4c, %o0                            
  total += count;                                                     
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
 2006ba0:	d6 07 60 54 	ld  [ %i5 + 0x54 ], %o3                        
                      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)",                    
                      count, rtems_fdisk_segment_queue_count (&fd->used));
  count = rtems_fdisk_segment_count_queue (&fd->erase);               
 2006ba4:	94 10 00 08 	mov  %o0, %o2                                  
  total += count;                                                     
 2006ba8:	b8 07 00 08 	add  %i4, %o0, %i4                             
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
 2006bac:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006bb0:	90 10 00 1d 	mov  %i5, %o0                                  
 2006bb4:	7f ff f8 a6 	call  2004e4c <rtems_fdisk_printf>             
 2006bb8:	92 12 61 80 	or  %o1, 0x180, %o1                            
                      count, rtems_fdisk_segment_queue_count (&fd->erase));
  count = rtems_fdisk_segment_count_queue (&fd->failed);              
 2006bbc:	7f ff f8 24 	call  2004c4c <rtems_fdisk_segment_count_queue>
 2006bc0:	90 07 60 58 	add  %i5, 0x58, %o0                            
  total += count;                                                     
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
 2006bc4:	d6 07 60 60 	ld  [ %i5 + 0x60 ], %o3                        
                      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)",                   
                      count, rtems_fdisk_segment_queue_count (&fd->erase));
  count = rtems_fdisk_segment_count_queue (&fd->failed);              
 2006bc8:	94 10 00 08 	mov  %o0, %o2                                  
  total += count;                                                     
 2006bcc:	b8 07 00 08 	add  %i4, %o0, %i4                             
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
 2006bd0:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006bd4:	90 10 00 1d 	mov  %i5, %o0                                  
 2006bd8:	7f ff f8 9d 	call  2004e4c <rtems_fdisk_printf>             
 2006bdc:	92 12 61 98 	or  %o1, 0x198, %o1                            
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
  for (device = 0; device < fd->device_count; device++)               
 2006be0:	c6 07 60 30 	ld  [ %i5 + 0x30 ], %g3                        
 2006be4:	84 10 20 00 	clr  %g2                                       
 2006be8:	82 10 20 00 	clr  %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;                                                          
 2006bec:	10 80 00 07 	b  2006c08 <rtems_fdisk_ioctl+0xe60>           
 2006bf0:	96 10 20 00 	clr  %o3                                       
  for (device = 0; device < fd->device_count; device++)               
 2006bf4:	82 00 60 01 	inc  %g1                                       
    count += fd->devices[device].segment_count;                       
 2006bf8:	88 01 00 02 	add  %g4, %g2, %g4                             
 2006bfc:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
 2006c00:	84 00 a0 0c 	add  %g2, 0xc, %g2                             
 2006c04:	96 02 c0 04 	add  %o3, %g4, %o3                             
  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++)               
 2006c08:	80 a0 40 03 	cmp  %g1, %g3                                  
 2006c0c:	32 bf ff fa 	bne,a   2006bf4 <rtems_fdisk_ioctl+0xe4c>      
 2006c10:	c8 07 60 2c 	ld  [ %i5 + 0x2c ], %g4                        
    count += fd->devices[device].segment_count;                       
                                                                      
  rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
 2006c14:	19 00 80 c4 	sethi  %hi(0x2031000), %o4                     
 2006c18:	80 a7 00 0b 	cmp  %i4, %o3                                  
 2006c1c:	12 80 00 04 	bne  2006c2c <rtems_fdisk_ioctl+0xe84>         <== NEVER TAKEN
 2006c20:	98 13 20 78 	or  %o4, 0x78, %o4                             
 2006c24:	19 00 80 c4 	sethi  %hi(0x2031000), %o4                     
 2006c28:	98 13 20 70 	or  %o4, 0x70, %o4	! 2031070 <__FUNCTION__.7127+0x998>
 2006c2c:	94 10 00 1c 	mov  %i4, %o2                                  
 2006c30:	90 10 00 1d 	mov  %i5, %o0                                  
 2006c34:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006c38:	7f ff f8 85 	call  2004e4c <rtems_fdisk_printf>             
 2006c3c:	92 12 61 b0 	or  %o1, 0x1b0, %o1	! 20315b0 <__FUNCTION__.7127+0xed8>
                      total == count ? "ok" : "MISSING");             
                                                                      
  rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);      
 2006c40:	d4 07 60 30 	ld  [ %i5 + 0x30 ], %o2                        
 2006c44:	90 10 00 1d 	mov  %i5, %o0                                  
 2006c48:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
                                                                      
        for (block = 0; block < fd->block_count; block++)             
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
              (fd->blocks[block].page == page) && !is_active)         
            rtems_fdisk_printf (fd,                                   
 2006c4c:	2d 00 80 c5 	sethi  %hi(0x2031400), %l6                     
    count += fd->devices[device].segment_count;                       
                                                                      
  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);      
 2006c50:	92 12 61 d0 	or  %o1, 0x1d0, %o1                            
 2006c54:	7f ff f8 7e 	call  2004e4c <rtems_fdisk_printf>             
 2006c58:	2f 00 80 c5 	sethi  %hi(0x2031400), %l7                     
 2006c5c:	b4 10 20 00 	clr  %i2                                       
                                                                      
  for (device = 0; device < fd->device_count; device++)               
 2006c60:	b2 10 20 00 	clr  %i1                                       
                                                                      
        for (block = 0; block < fd->block_count; block++)             
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
              (fd->blocks[block].page == page) && !is_active)         
            rtems_fdisk_printf (fd,                                   
 2006c64:	ac 15 a2 08 	or  %l6, 0x208, %l6                            
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
      }                                                               
                                                                      
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
 2006c68:	10 80 00 7b 	b  2006e54 <rtems_fdisk_ioctl+0x10ac>          
 2006c6c:	ae 15 e2 38 	or  %l7, 0x238, %l7                            
  for (device = 0; device < fd->device_count; device++)               
  {                                                                   
    uint32_t block;                                                   
    uint32_t seg;                                                     
                                                                      
    rtems_fdisk_printf (fd, " Device\t\t%ld", device);                
 2006c70:	90 10 00 1d 	mov  %i5, %o0                                  
 2006c74:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006c78:	7f ff f8 75 	call  2004e4c <rtems_fdisk_printf>             
 2006c7c:	92 12 61 e0 	or  %o1, 0x1e0, %o1	! 20315e0 <__FUNCTION__.7127+0xf08>
    rtems_fdisk_printf (fd, "  Segment count\t%ld",                   
 2006c80:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
 2006c84:	90 10 00 1d 	mov  %i5, %o0                                  
 2006c88:	82 00 40 1a 	add  %g1, %i2, %g1                             
 2006c8c:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
 2006c90:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
 2006c94:	a0 10 20 00 	clr  %l0                                       
 2006c98:	92 12 61 f0 	or  %o1, 0x1f0, %o1                            
 2006c9c:	7f ff f8 6c 	call  2004e4c <rtems_fdisk_printf>             
 2006ca0:	b0 10 20 00 	clr  %i0                                       
                        fd->devices[device].segment_count);           
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
 2006ca4:	10 80 00 65 	b  2006e38 <rtems_fdisk_ioctl+0x1090>          
 2006ca8:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
      uint32_t                 active = 0;                            
      uint32_t                 used = 0;                              
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
 2006cac:	90 10 00 1d 	mov  %i5, %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];
 2006cb0:	b8 07 00 10 	add  %i4, %l0, %i4                             
      uint32_t                 active = 0;                            
      uint32_t                 used = 0;                              
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
 2006cb4:	94 07 bf f8 	add  %fp, -8, %o2                              
 2006cb8:	92 10 00 1c 	mov  %i4, %o1                                  
 2006cbc:	7f ff f7 f8 	call  2004c9c <rtems_fdisk_queue_status>       
 2006cc0:	a2 10 20 00 	clr  %l1                                       
    {                                                                 
      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;                              
 2006cc4:	a6 10 20 00 	clr  %l3                                       
    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;                            
 2006cc8:	a8 10 20 00 	clr  %l4                                       
                                                                      
    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;                            
 2006ccc:	a4 10 20 00 	clr  %l2                                       
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
                                                                      
      for (page = 0; page < sc->pages; page++)                        
 2006cd0:	10 80 00 35 	b  2006da4 <rtems_fdisk_ioctl+0xffc>           
 2006cd4:	aa 10 20 00 	clr  %l5                                       
 * @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)   
 2006cd8:	85 2d 60 03 	sll  %l5, 3, %g2                               
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
                                                                      
      for (page = 0; page < sc->pages; page++)                        
      {                                                               
        if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
 2006cdc:	84 03 c0 02 	add  %o7, %g2, %g2                             
 2006ce0:	90 10 00 02 	mov  %g2, %o0                                  
 2006ce4:	7f ff f8 16 	call  2004d3c <rtems_fdisk_page_desc_erased>   
 2006ce8:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         
 2006cec:	80 8a 20 ff 	btst  0xff, %o0                                
 2006cf0:	02 80 00 04 	be  2006d00 <rtems_fdisk_ioctl+0xf58>          
 2006cf4:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
          erased++;                                                   
 2006cf8:	10 80 00 0c 	b  2006d28 <rtems_fdisk_ioctl+0xf80>           
 2006cfc:	a4 04 a0 01 	inc  %l2                                       
 * 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;                     
 2006d00:	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],
 2006d04:	80 88 a0 01 	btst  1, %g2                                   
 2006d08:	32 80 00 09 	bne,a   2006d2c <rtems_fdisk_ioctl+0xf84>      <== NEVER TAKEN
 2006d0c:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
                                                  RTEMS_FDISK_PAGE_ACTIVE))
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
 2006d10:	80 88 a0 02 	btst  2, %g2                                   
 2006d14:	32 80 00 04 	bne,a   2006d24 <rtems_fdisk_ioctl+0xf7c>      
 2006d18:	a8 05 20 01 	inc  %l4                                       
                                               RTEMS_FDISK_PAGE_USED))
            used++;                                                   
 2006d1c:	10 80 00 03 	b  2006d28 <rtems_fdisk_ioctl+0xf80>           
 2006d20:	a6 04 e0 01 	inc  %l3                                       
          else                                                        
          {                                                           
            active++;                                                 
            is_active = true;                                         
 2006d24:	a2 10 20 01 	mov  1, %l1                                    
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
 2006d28:	84 10 20 00 	clr  %g2                                       
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
              (fd->blocks[block].page == page) && !is_active)         
 2006d2c:	10 80 00 19 	b  2006d90 <rtems_fdisk_ioctl+0xfe8>           
 2006d30:	9a 0c 60 ff 	and  %l1, 0xff, %o5                            
 * @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)   
 2006d34:	9f 28 a0 03 	sll  %g2, 3, %o7                               
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
 2006d38:	96 03 00 0f 	add  %o4, %o7, %o3                             
 2006d3c:	de 03 00 0f 	ld  [ %o4 + %o7 ], %o7                         
 2006d40:	80 a3 c0 1c 	cmp  %o7, %i4                                  
 2006d44:	32 80 00 13 	bne,a   2006d90 <rtems_fdisk_ioctl+0xfe8>      
 2006d48:	84 00 a0 01 	inc  %g2                                       
 2006d4c:	de 02 e0 04 	ld  [ %o3 + 4 ], %o7                           
 2006d50:	80 a3 c0 15 	cmp  %o7, %l5                                  
 2006d54:	32 80 00 0f 	bne,a   2006d90 <rtems_fdisk_ioctl+0xfe8>      
 2006d58:	84 00 a0 01 	inc  %g2                                       
              (fd->blocks[block].page == page) && !is_active)         
 2006d5c:	80 a3 60 00 	cmp  %o5, 0                                    
 2006d60:	32 80 00 0c 	bne,a   2006d90 <rtems_fdisk_ioctl+0xfe8>      <== ALWAYS TAKEN
 2006d64:	84 00 a0 01 	inc  %g2                                       
            rtems_fdisk_printf (fd,                                   
 2006d68:	96 10 00 02 	mov  %g2, %o3                                  <== NOT EXECUTED
 2006d6c:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         <== NOT EXECUTED
 2006d70:	da 27 bf bc 	st  %o5, [ %fp + -68 ]                         <== NOT EXECUTED
 2006d74:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2006d78:	92 10 00 16 	mov  %l6, %o1                                  <== NOT EXECUTED
 2006d7c:	7f ff f8 34 	call  2004e4c <rtems_fdisk_printf>             <== NOT EXECUTED
 2006d80:	94 10 00 15 	mov  %l5, %o2                                  <== NOT EXECUTED
 2006d84:	da 07 bf bc 	ld  [ %fp + -68 ], %o5                         <== NOT EXECUTED
 2006d88:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         <== NOT EXECUTED
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
 2006d8c:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
 2006d90:	de 07 60 1c 	ld  [ %i5 + 0x1c ], %o7                        
 2006d94:	80 a0 80 0f 	cmp  %g2, %o7                                  
 2006d98:	2a bf ff e7 	bcs,a   2006d34 <rtems_fdisk_ioctl+0xf8c>      
 2006d9c:	d8 07 60 18 	ld  [ %i5 + 0x18 ], %o4                        
      bool                     is_active = false;                     
      char                     queues[5];                             
                                                                      
      rtems_fdisk_queue_status (fd, sc, queues);                      
                                                                      
      for (page = 0; page < sc->pages; page++)                        
 2006da0:	aa 05 60 01 	inc  %l5                                       
 2006da4:	d8 07 20 14 	ld  [ %i4 + 0x14 ], %o4                        
 2006da8:	80 a5 40 0c 	cmp  %l5, %o4                                  
 2006dac:	2a bf ff cb 	bcs,a   2006cd8 <rtems_fdisk_ioctl+0xf30>      
 2006db0:	de 07 20 10 	ld  [ %i4 + 0x10 ], %o7                        
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
 2006db4:	de 07 60 1c 	ld  [ %i5 + 0x1c ], %o7                        
 2006db8:	82 10 20 00 	clr  %g1                                       
 2006dbc:	10 80 00 08 	b  2006ddc <rtems_fdisk_ioctl+0x1034>          
 2006dc0:	84 10 20 00 	clr  %g2                                       
      {                                                               
        if (fd->blocks[block].segment == sc)                          
 2006dc4:	9b 28 60 03 	sll  %g1, 3, %o5                               
 2006dc8:	da 02 c0 0d 	ld  [ %o3 + %o5 ], %o5                         
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
 2006dcc:	82 00 60 01 	inc  %g1                                       
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
 2006dd0:	9a 1b 40 1c 	xor  %o5, %i4, %o5                             
 2006dd4:	80 a0 00 0d 	cmp  %g0, %o5                                  
 2006dd8:	84 60 bf ff 	subx  %g2, -1, %g2                             
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
 2006ddc:	80 a0 40 0f 	cmp  %g1, %o7                                  
 2006de0:	32 bf ff f9 	bne,a   2006dc4 <rtems_fdisk_ioctl+0x101c>     
 2006de4:	d6 07 60 18 	ld  [ %i5 + 0x18 ], %o3                        
                          " 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),
 2006de8:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
      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 +             
 2006dec:	da 07 20 1c 	ld  [ %i4 + 0x1c ], %o5                        
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
      }                                                               
                                                                      
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
 2006df0:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
 2006df4:	e8 23 a0 5c 	st  %l4, [ %sp + 0x5c ]                        
 2006df8:	e6 23 a0 64 	st  %l3, [ %sp + 0x64 ]                        
 2006dfc:	e4 23 a0 68 	st  %l2, [ %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)   
 2006e00:	c6 07 20 24 	ld  [ %i4 + 0x24 ], %g3                        
 2006e04:	82 03 40 01 	add  %o5, %g1, %g1                             
 2006e08:	82 00 40 03 	add  %g1, %g3, %g1                             
      {                                                               
        if (fd->blocks[block].segment == sc)                          
          count++;                                                    
      }                                                               
                                                                      
      rtems_fdisk_printf (fd, "  %3ld %s p:%3ld a:%3ld/%3ld" \        
 2006e0c:	82 23 00 01 	sub  %o4, %g1, %g1                             
 2006e10:	94 10 00 18 	mov  %i0, %o2                                  
 2006e14:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
 2006e18:	c4 23 a0 70 	st  %g2, [ %sp + 0x70 ]                        
 2006e1c:	90 10 00 1d 	mov  %i5, %o0                                  
 2006e20:	92 10 00 17 	mov  %l7, %o1                                  
 2006e24:	96 07 bf f8 	add  %fp, -8, %o3                              
 2006e28:	7f ff f8 09 	call  2004e4c <rtems_fdisk_printf>             
 2006e2c:	b0 06 20 01 	inc  %i0                                       
 2006e30:	a0 04 20 30 	add  %l0, 0x30, %l0                            
                                                                      
    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++)     
 2006e34:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
 2006e38:	84 00 40 1a 	add  %g1, %i2, %g2                             
 2006e3c:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
 2006e40:	80 a6 00 02 	cmp  %i0, %g2                                  
 2006e44:	2a bf ff 9a 	bcs,a   2006cac <rtems_fdisk_ioctl+0xf04>      
 2006e48:	f8 00 40 1a 	ld  [ %g1 + %i2 ], %i4                         
  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++)               
 2006e4c:	b2 06 60 01 	inc  %i1                                       
 2006e50:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             
 2006e54:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
 2006e58:	80 a6 40 01 	cmp  %i1, %g1                                  
 2006e5c:	0a bf ff 85 	bcs  2006c70 <rtems_fdisk_ioctl+0xec8>         
 2006e60:	94 10 00 19 	mov  %i1, %o2                                  
                          count);                                     
    }                                                                 
  }                                                                   
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
 2006e64:	f8 07 60 40 	ld  [ %i5 + 0x40 ], %i4                        
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
 2006e68:	90 10 00 1d 	mov  %i5, %o0                                  
 2006e6c:	13 00 80 c5 	sethi  %hi(0x2031400), %o1                     
    while (sc)                                                        
    {                                                                 
      rtems_fdisk_printf (fd, "  %3d %02d:%03d u:%3ld",               
 2006e70:	33 00 80 c5 	sethi  %hi(0x2031400), %i1                     
  }                                                                   
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
 2006e74:	92 12 62 78 	or  %o1, 0x278, %o1                            
 2006e78:	7f ff f7 f5 	call  2004e4c <rtems_fdisk_printf>             
 2006e7c:	b4 10 20 00 	clr  %i2                                       
    while (sc)                                                        
    {                                                                 
      rtems_fdisk_printf (fd, "  %3d %02d:%03d u:%3ld",               
 2006e80:	10 80 00 0a 	b  2006ea8 <rtems_fdisk_ioctl+0x1100>          
 2006e84:	b2 16 62 88 	or  %i1, 0x288, %i1                            
 2006e88:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
 2006e8c:	da 07 20 20 	ld  [ %i4 + 0x20 ], %o5                        
 2006e90:	94 10 00 1a 	mov  %i2, %o2                                  
 2006e94:	90 10 00 1d 	mov  %i5, %o0                                  
 2006e98:	7f ff f7 ed 	call  2004e4c <rtems_fdisk_printf>             
 2006e9c:	92 10 00 19 	mov  %i1, %o1                                  
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
 2006ea0:	f8 07 00 00 	ld  [ %i4 ], %i4                               
      count++;                                                        
 2006ea4:	b4 06 a0 01 	inc  %i2                                       
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
    while (sc)                                                        
 2006ea8:	80 a7 20 00 	cmp  %i4, 0                                    
 2006eac:	32 bf ff f7 	bne,a   2006e88 <rtems_fdisk_ioctl+0x10e0>     
 2006eb0:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
      count++;                                                        
    }                                                                 
  }                                                                   
  fd->info_level = current_info_level;                                
 2006eb4:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
      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]);  
 2006eb8:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
      count++;                                                        
    }                                                                 
  }                                                                   
  fd->info_level = current_info_level;                                
 2006ebc:	c2 27 60 6c 	st  %g1, [ %i5 + 0x6c ]                        
        rtems_flashdisks[minor].info_level = (uintptr_t) argp;        
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_PRINT_STATUS:                            
        errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);  
        break;                                                        
 2006ec0:	10 80 00 05 	b  2006ed4 <rtems_fdisk_ioctl+0x112c>          
 2006ec4:	c0 20 80 00 	clr  [ %g2 ]                                   
                                                                      
      default:                                                        
        rtems_blkdev_ioctl (dd, req, argp);                           
 2006ec8:	92 10 00 19 	mov  %i1, %o1                                  
 2006ecc:	40 00 3c 48 	call  2015fec <rtems_blkdev_ioctl>             
 2006ed0:	94 10 00 1a 	mov  %i2, %o2                                  
        break;                                                        
    }                                                                 
                                                                      
    sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);      
 2006ed4:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     
 2006ed8:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1	! 2046480 <rtems_flashdisks>
 2006edc:	b6 00 40 1b 	add  %g1, %i3, %i3                             
 2006ee0:	40 00 17 1c 	call  200cb50 <rtems_semaphore_release>        
 2006ee4:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        
    if (sc != RTEMS_SUCCESSFUL)                                       
 2006ee8:	80 a2 20 00 	cmp  %o0, 0                                    
 2006eec:	02 80 00 06 	be  2006f04 <rtems_fdisk_ioctl+0x115c>         <== ALWAYS TAKEN
 2006ef0:	01 00 00 00 	nop                                            
      errno = EIO;                                                    
 2006ef4:	40 00 66 cb 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2006ef8:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2006efc:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
 2006f00:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return errno == 0 ? 0 : -1;                                         
 2006f04:	40 00 66 c7 	call  2020a20 <__errno>                        
 2006f08:	01 00 00 00 	nop                                            
 2006f0c:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 2006f10:	80 a0 00 01 	cmp  %g0, %g1                                  
 2006f14:	b0 60 20 00 	subx  %g0, 0, %i0                              
 2006f18:	81 c7 e0 08 	ret                                            
 2006f1c:	81 e8 00 00 	restore                                        
    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)                  
 2006f20:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
 2006f24:	a2 04 60 01 	inc  %l1                                       
 2006f28:	10 bf fc 84 	b  2006138 <rtems_fdisk_ioctl+0x390>           
 2006f2c:	a0 04 00 01 	add  %l0, %g1, %l0                             
{                                                                     
  rtems_blkdev_sg_buffer* sg = req->bufs;                             
  uint32_t                buf;                                        
  int                     ret = 0;                                    
                                                                      
  for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)       
 2006f30:	10 bf fc 88 	b  2006150 <rtems_fdisk_ioctl+0x3a8>           <== NOT EXECUTED
 2006f34:	a4 04 a0 01 	inc  %l2                                       <== NOT EXECUTED
                                                                      

020050c0 <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) {
 20050c0:	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",
 20050c4:	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)
{                                                                     
 20050c8:	ba 10 00 18 	mov  %i0, %i5                                  
 20050cc:	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",
 20050d0:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
 20050d4:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
 20050d8:	d8 06 60 14 	ld  [ %i1 + 0x14 ], %o4                        
 20050dc:	da 06 60 1c 	ld  [ %i1 + 0x1c ], %o5                        
 20050e0:	c8 06 60 20 	ld  [ %i1 + 0x20 ], %g4                        
 20050e4:	80 a0 60 00 	cmp  %g1, 0                                    
 20050e8:	02 80 00 05 	be  20050fc <rtems_fdisk_queue_segment+0x3c>   <== ALWAYS TAKEN
 20050ec:	c6 06 60 24 	ld  [ %i1 + 0x24 ], %g3                        
 20050f0:	05 00 80 c3 	sethi  %hi(0x2030c00), %g2                     <== NOT EXECUTED
 20050f4:	10 80 00 04 	b  2005104 <rtems_fdisk_queue_segment+0x44>    <== NOT EXECUTED
 20050f8:	84 10 a0 08 	or  %g2, 8, %g2	! 2030c08 <__FUNCTION__.7127+0x530><== NOT EXECUTED
 20050fc:	05 00 80 c3 	sethi  %hi(0x2030c00), %g2                     
 2005100:	84 10 a0 10 	or  %g2, 0x10, %g2	! 2030c10 <__FUNCTION__.7127+0x538>
 2005104:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 2005108:	80 a0 60 00 	cmp  %g1, 0                                    
 200510c:	02 80 00 04 	be  200511c <rtems_fdisk_queue_segment+0x5c>   
 2005110:	03 00 80 c3 	sethi  %hi(0x2030c00), %g1                     
 2005114:	10 80 00 04 	b  2005124 <rtems_fdisk_queue_segment+0x64>    
 2005118:	82 10 60 18 	or  %g1, 0x18, %g1	! 2030c18 <__FUNCTION__.7127+0x540>
 200511c:	03 00 80 c3 	sethi  %hi(0x2030c00), %g1                     
 2005120:	82 10 60 20 	or  %g1, 0x20, %g1	! 2030c20 <__FUNCTION__.7127+0x548>
 2005124:	c2 23 a0 68 	st  %g1, [ %sp + 0x68 ]                        
 2005128:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
 200512c:	c6 23 a0 60 	st  %g3, [ %sp + 0x60 ]                        
 2005130:	c4 23 a0 64 	st  %g2, [ %sp + 0x64 ]                        
 2005134:	90 10 00 1d 	mov  %i5, %o0                                  
 2005138:	13 00 80 c3 	sethi  %hi(0x2030c00), %o1                     
 200513c:	7f ff ff 24 	call  2004dcc <rtems_fdisk_info>               
 2005140:	92 12 60 28 	or  %o1, 0x28, %o1	! 2030c28 <__FUNCTION__.7127+0x550>
                                                                      
  /*                                                                  
   * If the segment has failed then check the failed queue and append 
   * if not failed.                                                   
   */                                                                 
  if (sc->failed)                                                     
 2005144:	c2 06 a0 28 	ld  [ %i2 + 0x28 ], %g1                        
 2005148:	80 a0 60 00 	cmp  %g1, 0                                    
 200514c:	02 80 00 09 	be  2005170 <rtems_fdisk_queue_segment+0xb0>   <== ALWAYS TAKEN
 2005150:	92 10 00 1a 	mov  %i2, %o1                                  
  {                                                                   
    if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))         
 2005154:	b0 07 60 58 	add  %i5, 0x58, %i0                            <== NOT EXECUTED
 2005158:	7f ff fe c6 	call  2004c70 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
 200515c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2005160:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2005164:	12 80 00 32 	bne  200522c <rtems_fdisk_queue_segment+0x16c> <== NOT EXECUTED
 2005168:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200516c:	30 80 00 2e 	b,a   2005224 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Remove the queue from the available or used queue.               
   */                                                                 
  rtems_fdisk_segment_queue_remove (&fd->available, sc);              
 2005170:	b8 07 60 34 	add  %i5, 0x34, %i4                            
 2005174:	7f ff fe 84 	call  2004b84 <rtems_fdisk_segment_queue_remove>
 2005178:	90 10 00 1c 	mov  %i4, %o0                                  
  rtems_fdisk_segment_queue_remove (&fd->used, sc);                   
 200517c:	92 10 00 1a 	mov  %i2, %o1                                  
 2005180:	b0 07 60 40 	add  %i5, 0x40, %i0                            
 2005184:	7f ff fe 80 	call  2004b84 <rtems_fdisk_segment_queue_remove>
 2005188:	90 10 00 18 	mov  %i0, %o0                                  
   * 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)                      
 200518c:	7f ff fe f6 	call  2004d64 <rtems_fdisk_seg_pages_available>
 2005190:	90 10 00 1a 	mov  %i2, %o0                                  
 2005194:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2005198:	32 80 00 1d 	bne,a   200520c <rtems_fdisk_queue_segment+0x14c>
 200519c:	f2 07 60 34 	ld  [ %i5 + 0x34 ], %i1                        
  {                                                                   
    if (sc->pages_active)                                             
 20051a0:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
 20051a4:	80 a0 60 00 	cmp  %g1, 0                                    
 20051a8:	22 80 00 0d 	be,a   20051dc <rtems_fdisk_queue_segment+0x11c><== NEVER TAKEN
 20051ac:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
       * 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)                                                     
 20051b0:	10 80 00 07 	b  20051cc <rtems_fdisk_queue_segment+0x10c>   
 20051b4:	f2 07 60 40 	ld  [ %i5 + 0x40 ], %i1                        
      {                                                               
        if (sc->pages_used > seg->pages_used)                         
 20051b8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 20051bc:	80 a0 80 01 	cmp  %g2, %g1                                  
 20051c0:	18 80 00 17 	bgu  200521c <rtems_fdisk_queue_segment+0x15c> 
 20051c4:	01 00 00 00 	nop                                            
          break;                                                      
        seg = seg->next;                                              
 20051c8:	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)                                                     
 20051cc:	80 a6 60 00 	cmp  %i1, 0                                    
 20051d0:	32 bf ff fa 	bne,a   20051b8 <rtems_fdisk_queue_segment+0xf8>
 20051d4:	c4 06 a0 20 	ld  [ %i2 + 0x20 ], %g2                        
 20051d8:	30 80 00 13 	b,a   2005224 <rtems_fdisk_queue_segment+0x164>
      else                                                            
        rtems_fdisk_segment_queue_push_tail (&fd->used, sc);          
    }                                                                 
    else                                                              
    {                                                                 
      if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))                 
 20051dc:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
 20051e0:	12 80 00 11 	bne  2005224 <rtems_fdisk_queue_segment+0x164> <== NOT EXECUTED
 20051e4:	b0 07 60 4c 	add  %i5, 0x4c, %i0                            <== NOT EXECUTED
        rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);         
      else                                                            
        rtems_fdisk_erase_segment (fd, sc);                           
 20051e8:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 20051ec:	7f ff ff 75 	call  2004fc0 <rtems_fdisk_erase_segment>      <== NOT EXECUTED
 20051f0:	93 e8 00 1a 	restore  %g0, %i2, %o1                         <== NOT EXECUTED
    rtems_fdisk_segment_ctl* seg = fd->available.head;                
                                                                      
    while (seg)                                                       
    {                                                                 
      if (rtems_fdisk_seg_pages_available (sc) <                      
          rtems_fdisk_seg_pages_available (seg))                      
 20051f4:	7f ff fe dc 	call  2004d64 <rtems_fdisk_seg_pages_available>
 20051f8:	90 10 00 19 	mov  %i1, %o0                                  
     */                                                               
    rtems_fdisk_segment_ctl* seg = fd->available.head;                
                                                                      
    while (seg)                                                       
    {                                                                 
      if (rtems_fdisk_seg_pages_available (sc) <                      
 20051fc:	80 a6 c0 08 	cmp  %i3, %o0                                  
 2005200:	0a 80 00 07 	bcs  200521c <rtems_fdisk_queue_segment+0x15c> 
 2005204:	b0 10 00 1c 	mov  %i4, %i0                                  
          rtems_fdisk_seg_pages_available (seg))                      
        break;                                                        
      seg = seg->next;                                                
 2005208:	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)                                                       
 200520c:	80 a6 60 00 	cmp  %i1, 0                                    
 2005210:	12 bf ff f9 	bne  20051f4 <rtems_fdisk_queue_segment+0x134> 
 2005214:	b0 10 00 1c 	mov  %i4, %i0                                  
 2005218:	30 80 00 03 	b,a   2005224 <rtems_fdisk_queue_segment+0x164>
        break;                                                        
      seg = seg->next;                                                
    }                                                                 
                                                                      
    if (seg)                                                          
      rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
 200521c:	7f ff fe 77 	call  2004bf8 <rtems_fdisk_segment_queue_insert_before>
 2005220:	81 e8 00 00 	restore                                        
    else                                                              
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
 2005224:	7f ff fe 46 	call  2004b3c <rtems_fdisk_segment_queue_push_tail>
 2005228:	93 e8 00 1a 	restore  %g0, %i2, %o1                         
 200522c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2005230:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200541c <rtems_fdisk_recover_block_mappings>: /** * Recover the block mappings from the devices. */ static int rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd) {
 200541c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_fdisk_segment_queue_init (&fd->failed);                       
                                                                      
  /*                                                                  
   * Clear the lock mappings.                                         
   */                                                                 
  memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
 2005420:	d4 06 20 1c 	ld  [ %i0 + 0x1c ], %o2                        
 2005424:	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;                                      
 2005428:	c0 26 20 38 	clr  [ %i0 + 0x38 ]                            
 200542c:	c0 26 20 34 	clr  [ %i0 + 0x34 ]                            
  queue->count = 0;                                                   
 2005430:	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;                                      
 2005434:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            
 2005438:	c0 26 20 40 	clr  [ %i0 + 0x40 ]                            
  queue->count = 0;                                                   
 200543c:	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;                                      
 2005440:	c0 26 20 50 	clr  [ %i0 + 0x50 ]                            
 2005444:	c0 26 20 4c 	clr  [ %i0 + 0x4c ]                            
  queue->count = 0;                                                   
 2005448:	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;                                      
 200544c:	c0 26 20 5c 	clr  [ %i0 + 0x5c ]                            
 2005450:	c0 26 20 58 	clr  [ %i0 + 0x58 ]                            
  queue->count = 0;                                                   
 2005454:	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));
 2005458:	92 10 20 00 	clr  %o1                                       
 200545c:	95 2a a0 03 	sll  %o2, 3, %o2                               
 2005460:	40 00 72 4b 	call  2021d8c <memset>                         
 2005464:	27 00 80 c3 	sethi  %hi(0x2030c00), %l3                     
               * 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: " \      
 2005468:	29 00 80 c3 	sethi  %hi(0x2030c00), %l4                     
          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,                                
 200546c:	2b 00 80 c3 	sethi  %hi(0x2030c00), %l5                     
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
 2005470:	2d 00 80 c3 	sethi  %hi(0x2030c00), %l6                     
            ret = rtems_fdisk_seg_write_page_desc (fd, sc,            
                                                   page, pd);         
                                                                      
            if (ret)                                                  
            {                                                         
              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
 2005474:	2f 00 80 c3 	sethi  %hi(0x2030c00), %l7                     
/**                                                                   
 * Recover the block mappings from the devices.                       
 */                                                                   
static int                                                            
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)              
{                                                                     
 2005478:	ba 10 00 18 	mov  %i0, %i5                                  
  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;                                              
 200547c:	c0 26 20 28 	clr  [ %i0 + 0x28 ]                            
  fd->starvation_threshold = 0;                                       
 2005480:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
  for (device = 0; device < fd->device_count; device++)               
 2005484:	a2 10 20 00 	clr  %l1                                       
 2005488:	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);
 200548c:	a6 14 e0 d8 	or  %l3, 0xd8, %l3                             
               * 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: " \      
 2005490:	a8 15 21 c0 	or  %l4, 0x1c0, %l4                            
          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,                                
 2005494:	aa 15 61 90 	or  %l5, 0x190, %l5                            
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
 2005498:	ac 15 a1 48 	or  %l6, 0x148, %l6                            
  /*                                                                  
   * 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++)               
 200549c:	10 80 00 b3 	b  2005768 <rtems_fdisk_recover_block_mappings+0x34c>
 20054a0:	ae 15 e1 68 	or  %l7, 0x168, %l7                            
      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);
 20054a4:	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];
 20054a8:	b8 07 00 12 	add  %i4, %l2, %i4                             
      const rtems_fdisk_segment_desc* sd = sc->descriptor;            
 20054ac:	f6 07 20 04 	ld  [ %i4 + 4 ], %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);
 20054b0:	96 10 00 10 	mov  %l0, %o3                                  
 20054b4:	92 10 00 13 	mov  %l3, %o1                                  
 20054b8:	7f ff fe 45 	call  2004dcc <rtems_fdisk_info>               
 20054bc:	90 10 00 1d 	mov  %i5, %o0                                  
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
 20054c0:	d0 06 e0 08 	ld  [ %i3 + 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);
 20054c4:	f4 07 60 14 	ld  [ %i5 + 0x14 ], %i2                        
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
 20054c8:	7f ff f4 6d 	call  200267c <.udiv>                          
 20054cc:	92 10 00 1a 	mov  %i2, %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;                               
 20054d0:	92 10 00 1a 	mov  %i2, %o1                                  
 */                                                                   
static uint32_t                                                       
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,     
                              uint32_t                        page_size)
{                                                                     
  return sd->size / page_size;                                        
 20054d4:	b6 10 00 08 	mov  %o0, %i3                                  
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);            
 20054d8:	91 2a 20 03 	sll  %o0, 3, %o0                               
  return ((bytes - 1) / page_size) + 1;                               
 20054dc:	7f ff f4 68 	call  200267c <.udiv>                          
 20054e0:	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)                       
 20054e4:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
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;                               
 20054e8:	b0 02 20 01 	add  %o0, 1, %i0                               
      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;
 20054ec:	90 26 c0 18 	sub  %i3, %i0, %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);
 20054f0:	f0 27 20 18 	st  %i0, [ %i4 + 0x18 ]                        
      sc->pages =                                                     
        rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
      if (sc->pages > fd->starvation_threshold)                       
 20054f4:	80 a2 00 01 	cmp  %o0, %g1                                  
 20054f8:	08 80 00 03 	bleu  2005504 <rtems_fdisk_recover_block_mappings+0xe8>
 20054fc:	d0 27 20 14 	st  %o0, [ %i4 + 0x14 ]                        
        fd->starvation_threshold = sc->pages;                         
 2005500:	d0 27 60 24 	st  %o0, [ %i5 + 0x24 ]                        
      sc->pages_used   = 0;                                           
      sc->pages_bad    = 0;                                           
                                                                      
      sc->failed = false;                                             
                                                                      
      if (!sc->page_descriptors)                                      
 2005504:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
      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;                                           
 2005508:	c0 27 20 1c 	clr  [ %i4 + 0x1c ]                            
      sc->pages_used   = 0;                                           
 200550c:	c0 27 20 20 	clr  [ %i4 + 0x20 ]                            
      sc->pages_bad    = 0;                                           
 2005510:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            
                                                                      
      sc->failed = false;                                             
                                                                      
      if (!sc->page_descriptors)                                      
 2005514:	80 a0 60 00 	cmp  %g1, 0                                    
 2005518:	12 80 00 08 	bne  2005538 <rtems_fdisk_recover_block_mappings+0x11c><== NEVER TAKEN
 200551c:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            
        sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
 2005520:	92 10 00 1a 	mov  %i2, %o1                                  
 2005524:	7f ff f4 1c 	call  2002594 <.umul>                          
 2005528:	90 10 00 18 	mov  %i0, %o0                                  
 200552c:	40 00 0c 3f 	call  2008628 <malloc>                         
 2005530:	01 00 00 00 	nop                                            
 2005534:	d0 27 20 10 	st  %o0, [ %i4 + 0x10 ]                        
                                                                      
      if (!sc->page_descriptors)                                      
 2005538:	f6 07 20 10 	ld  [ %i4 + 0x10 ], %i3                        
 200553c:	80 a6 e0 00 	cmp  %i3, 0                                    
 2005540:	32 80 00 05 	bne,a   2005554 <rtems_fdisk_recover_block_mappings+0x138><== ALWAYS TAKEN
 2005544:	90 10 00 18 	mov  %i0, %o0                                  
        rtems_fdisk_abort ("no memory for page descriptors");         
 2005548:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 200554c:	40 00 07 ba 	call  2007434 <rtems_fdisk_abort.constprop.0>  <== NOT EXECUTED
 2005550:	90 12 23 b0 	or  %o0, 0x3b0, %o0	! 2030bb0 <__FUNCTION__.7127+0x4d8><== 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,              
 2005554:	7f ff f4 10 	call  2002594 <.umul>                          
 2005558:	92 10 00 1a 	mov  %i2, %o1                                  
 200555c:	92 10 00 1c 	mov  %i4, %o1                                  
 2005560:	98 10 00 08 	mov  %o0, %o4                                  
 2005564:	94 10 20 00 	clr  %o2                                       
 2005568:	90 10 00 1d 	mov  %i5, %o0                                  
 200556c:	7f ff ff 32 	call  2005234 <rtems_fdisk_seg_read>           
 2005570:	96 10 00 1b 	mov  %i3, %o3                                  
                                  sc->pages_desc * fd->block_size);   
                                                                      
      if (ret)                                                        
 2005574:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2005578:	22 80 00 6a 	be,a   2005720 <rtems_fdisk_recover_block_mappings+0x304><== ALWAYS TAKEN
 200557c:	b4 10 20 00 	clr  %i2                                       
      {                                                               
        rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \     
 2005580:	40 00 76 ed 	call  2023134 <strerror>                       <== NOT EXECUTED
 2005584:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2005588:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 200558c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2005590:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 2005594:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 2005598:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
 200559c:	7f ff fe 6c 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20055a0:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
                           "read page desc failed: %s (%d)",          
                           device, segment, strerror (ret), ret);     
        return ret;                                                   
 20055a4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20055a8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
       * 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++)                  
      {                                                               
        if (rtems_fdisk_page_desc_erased (pd))                        
 20055ac:	7f ff fd e4 	call  2004d3c <rtems_fdisk_page_desc_erased>   
 20055b0:	90 10 00 1b 	mov  %i3, %o0                                  
 20055b4:	80 8a 20 ff 	btst  0xff, %o0                                
 20055b8:	22 80 00 2b 	be,a   2005664 <rtems_fdisk_recover_block_mappings+0x248><== NEVER TAKEN
 20055bc:	c2 16 e0 02 	lduh  [ %i3 + 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);
 20055c0:	f0 07 60 14 	ld  [ %i5 + 0x14 ], %i0                        
        if (rtems_fdisk_page_desc_erased (pd))                        
        {                                                             
          /*                                                          
           * Is the page erased ?                                     
           */                                                         
          ret = rtems_fdisk_seg_blank_check_page (fd, sc,             
 20055c4:	d0 07 20 18 	ld  [ %i4 + 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,                         
 20055c8:	92 10 00 18 	mov  %i0, %o1                                  
 20055cc:	7f ff f3 f2 	call  2002594 <.umul>                          
 20055d0:	90 06 80 08 	add  %i2, %o0, %o0                             
 20055d4:	92 10 00 1c 	mov  %i4, %o1                                  
 20055d8:	94 10 00 08 	mov  %o0, %o2                                  
 20055dc:	96 10 00 18 	mov  %i0, %o3                                  
 20055e0:	7f ff ff 37 	call  20052bc <rtems_fdisk_seg_blank_check>    
 20055e4:	90 10 00 1d 	mov  %i5, %o0                                  
           * Is the page erased ?                                     
           */                                                         
          ret = rtems_fdisk_seg_blank_check_page (fd, sc,             
                                                  page + sc->pages_desc);
                                                                      
          if (ret == 0)                                               
 20055e8:	80 a2 20 00 	cmp  %o0, 0                                    
 20055ec:	32 80 00 06 	bne,a   2005604 <rtems_fdisk_recover_block_mappings+0x1e8><== NEVER TAKEN
 20055f0:	da 06 e0 04 	ld  [ %i3 + 4 ], %o5                           <== NOT EXECUTED
          {                                                           
            ++fd->erased_blocks;                                      
 20055f4:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
 20055f8:	82 00 60 01 	inc  %g1                                       
 20055fc:	10 80 00 47 	b  2005718 <rtems_fdisk_recover_block_mappings+0x2fc>
 2005600:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
 2005604:	92 10 00 16 	mov  %l6, %o1                                  <== NOT EXECUTED
 2005608:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
 200560c:	96 10 00 10 	mov  %l0, %o3                                  <== NOT EXECUTED
 2005610:	98 10 00 1a 	mov  %i2, %o4                                  <== NOT EXECUTED
 2005614:	7f ff fe 2e 	call  2004ecc <rtems_fdisk_warning>            <== NOT EXECUTED
 2005618:	90 10 00 1d 	mov  %i5, %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;                                                
 200561c:	c2 16 e0 02 	lduh  [ %i3 + 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,            
 2005620:	90 10 00 1d 	mov  %i5, %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;                                                
 2005624:	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,            
 2005628:	92 10 00 1c 	mov  %i4, %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;                                                
 200562c:	c2 36 e0 02 	sth  %g1, [ %i3 + 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,            
 2005630:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 2005634:	7f ff ff 69 	call  20053d8 <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
 2005638:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
                                                   page, pd);         
                                                                      
            if (ret)                                                  
 200563c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2005640:	22 80 00 0d 	be,a   2005674 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
 2005644:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        <== NOT EXECUTED
            {                                                         
              rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
 2005648:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
 200564c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2005650:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 2005654:	7f ff fe 3e 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005658:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
        }                                                             
        else                                                          
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
          {                                                           
            sc->pages_used++;                                         
 200565c:	10 80 00 06 	b  2005674 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
 2005660:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        <== NOT EXECUTED
            sc->pages_used++;                                         
          }                                                           
        }                                                             
        else                                                          
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
 2005664:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
 2005668:	12 80 00 06 	bne  2005680 <rtems_fdisk_recover_block_mappings+0x264><== NOT EXECUTED
 200566c:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
          {                                                           
            sc->pages_used++;                                         
 2005670:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        <== NOT EXECUTED
 2005674:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
 2005678:	10 80 00 28 	b  2005718 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
 200567c:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        <== NOT EXECUTED
          }                                                           
          else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
 2005680:	32 80 00 24 	bne,a   2005710 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
 2005684:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        <== NOT EXECUTED
          {                                                           
            if (pd->block >= fd->block_count)                         
 2005688:	da 06 e0 04 	ld  [ %i3 + 4 ], %o5                           <== NOT EXECUTED
 200568c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
 2005690:	80 a3 40 01 	cmp  %o5, %g1                                  <== NOT EXECUTED
 2005694:	2a 80 00 0a 	bcs,a   20056bc <rtems_fdisk_recover_block_mappings+0x2a0><== NOT EXECUTED
 2005698:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        <== NOT EXECUTED
            {                                                         
#if RTEMS_FDISK_TRACE                                                 
              rtems_fdisk_warning (fd,                                
 200569c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20056a0:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
 20056a4:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
 20056a8:	96 10 00 10 	mov  %l0, %o3                                  <== NOT EXECUTED
 20056ac:	7f ff fe 08 	call  2004ecc <rtems_fdisk_warning>            <== NOT EXECUTED
 20056b0:	98 10 00 1a 	mov  %i2, %o4                                  <== NOT EXECUTED
               */                                                     
              sc->pages_active++;                                     
            }                                                         
          }                                                           
          else                                                        
            sc->pages_bad++;                                          
 20056b4:	10 80 00 17 	b  2005710 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
 20056b8:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        <== 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)                   
 20056bc:	9b 2b 60 03 	sll  %o5, 3, %o5                               <== NOT EXECUTED
 20056c0:	c4 00 40 0d 	ld  [ %g1 + %o5 ], %g2                         <== NOT EXECUTED
 20056c4:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
 20056c8:	02 80 00 0c 	be  20056f8 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
 20056cc:	86 00 40 0d 	add  %g1, %o5, %g3                             <== 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: " \      
 20056d0:	d2 00 a0 08 	ld  [ %g2 + 8 ], %o1                           <== NOT EXECUTED
 20056d4:	d4 00 a0 0c 	ld  [ %g2 + 0xc ], %o2                         <== NOT EXECUTED
 20056d8:	d6 00 e0 04 	ld  [ %g3 + 4 ], %o3                           <== NOT EXECUTED
 20056dc:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
 20056e0:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        <== NOT EXECUTED
 20056e4:	98 10 00 19 	mov  %i1, %o4                                  <== NOT EXECUTED
 20056e8:	7f ff fe 19 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20056ec:	9a 10 00 10 	mov  %l0, %o5                                  <== NOT EXECUTED
               */                                                     
              sc->pages_active++;                                     
            }                                                         
          }                                                           
          else                                                        
            sc->pages_bad++;                                          
 20056f0:	10 80 00 08 	b  2005710 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
 20056f4:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        <== NOT EXECUTED
            {                                                         
              /**                                                     
               * @todo                                                
               * Add start up crc checks here.                        
               */                                                     
              fd->blocks[pd->block].segment = sc;                     
 20056f8:	f8 20 40 0d 	st  %i4, [ %g1 + %o5 ]                         <== NOT EXECUTED
              fd->blocks[pd->block].page    = page;                   
                                                                      
              /*                                                      
               * The page is active.                                  
               */                                                     
              sc->pages_active++;                                     
 20056fc:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        <== NOT EXECUTED
              /**                                                     
               * @todo                                                
               * Add start up crc checks here.                        
               */                                                     
              fd->blocks[pd->block].segment = sc;                     
              fd->blocks[pd->block].page    = page;                   
 2005700:	f4 20 e0 04 	st  %i2, [ %g3 + 4 ]                           <== NOT EXECUTED
                                                                      
              /*                                                      
               * The page is active.                                  
               */                                                     
              sc->pages_active++;                                     
 2005704:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
 2005708:	10 80 00 04 	b  2005718 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
 200570c:	c2 27 20 1c 	st  %g1, [ %i4 + 0x1c ]                        <== NOT EXECUTED
            }                                                         
          }                                                           
          else                                                        
            sc->pages_bad++;                                          
 2005710:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
 2005714:	c2 27 20 24 	st  %g1, [ %i4 + 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++)                  
 2005718:	b4 06 a0 01 	inc  %i2                                       
 200571c:	b6 06 e0 08 	add  %i3, 8, %i3                               
 2005720:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
 2005724:	80 a6 80 01 	cmp  %i2, %g1                                  
 2005728:	0a bf ff a1 	bcs  20055ac <rtems_fdisk_recover_block_mappings+0x190>
 200572c:	90 10 00 1d 	mov  %i5, %o0                                  
      }                                                               
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
 2005730:	92 10 00 1c 	mov  %i4, %o1                                  
 2005734:	7f ff fe 63 	call  20050c0 <rtems_fdisk_queue_segment>      
 2005738:	a0 04 20 01 	inc  %l0                                       
 200573c:	10 80 00 03 	b  2005748 <rtems_fdisk_recover_block_mappings+0x32c>
 2005740:	a4 04 a0 30 	add  %l2, 0x30, %l2                            
  /*                                                                  
   * 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++)               
 2005744:	a0 10 20 00 	clr  %l0                                       
  {                                                                   
    uint32_t segment;                                                 
    for (segment = 0; segment < fd->devices[device].segment_count; segment++)
 2005748:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
 200574c:	84 00 40 11 	add  %g1, %l1, %g2                             
 2005750:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
 2005754:	80 a4 00 02 	cmp  %l0, %g2                                  
 2005758:	2a bf ff 53 	bcs,a   20054a4 <rtems_fdisk_recover_block_mappings+0x88>
 200575c:	f8 00 40 11 	ld  [ %g1 + %l1 ], %i4                         
  /*                                                                  
   * 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++)               
 2005760:	b2 06 60 01 	inc  %i1                                       
 2005764:	a2 04 60 0c 	add  %l1, 0xc, %l1                             
 2005768:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
 200576c:	80 a6 40 01 	cmp  %i1, %g1                                  
 2005770:	0a bf ff f5 	bcs  2005744 <rtems_fdisk_recover_block_mappings+0x328>
 2005774:	a4 10 20 00 	clr  %l2                                       
      rtems_fdisk_queue_segment (fd, sc);                             
    }                                                                 
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2005778:	81 c7 e0 08 	ret                                            
 200577c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

020057ec <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) {
 20057ec:	9d e3 bf 80 	save  %sp, -128, %sp                           
  int      ret;                                                       
  uint32_t spage;                                                     
  uint32_t used = 0;                                                  
 20057f0:	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);        
 20057f4:	82 06 20 34 	add  %i0, 0x34, %g1                            
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
                                    rtems_fdisk_segment_ctl* ssc,     
                                    rtems_fdisk_segment_ctl* dsc,     
                                    uint32_t *pages)                  
{                                                                     
 20057f8:	aa 10 00 19 	mov  %i1, %l5                                  
 20057fc:	a2 10 00 1a 	mov  %i2, %l1                                  
  int      ret;                                                       
  uint32_t spage;                                                     
  uint32_t used = 0;                                                  
  uint32_t active = 0;                                                
 2005800:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
 2005804:	b8 10 20 00 	clr  %i4                                       
 2005808:	10 80 00 c2 	b  2005b10 <rtems_fdisk_recycle_segment+0x324> 
 200580c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
 2005810:	ad 2f 20 03 	sll  %i4, 3, %l6                               
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
  {                                                                   
    rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];       
                                                                      
    if (!dsc && ssc->pages_active > 0)                                
 2005814:	80 a4 60 00 	cmp  %l1, 0                                    
 2005818:	12 80 00 0b 	bne  2005844 <rtems_fdisk_recycle_segment+0x58>
 200581c:	a0 05 c0 16 	add  %l7, %l6, %l0                             
 2005820:	c6 05 60 1c 	ld  [ %l5 + 0x1c ], %g3                        
 2005824:	80 a0 e0 00 	cmp  %g3, 0                                    
 2005828:	22 80 00 08 	be,a   2005848 <rtems_fdisk_recycle_segment+0x5c><== ALWAYS TAKEN
 200582c:	c6 14 20 02 	lduh  [ %l0 + 2 ], %g3                         
    {                                                                 
      rtems_fdisk_error ("recycle: no available dst segment");        
 2005830:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 2005834:	7f ff fd c6 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005838:	90 12 21 f0 	or  %o0, 0x1f0, %o0	! 2030df0 <__FUNCTION__.7127+0x718><== 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;                                                   
 200583c:	10 80 00 ca 	b  2005b64 <rtems_fdisk_recycle_segment+0x378> <== NOT EXECUTED
 2005840:	a8 10 20 05 	mov  5, %l4                                    <== NOT EXECUTED
 * 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;                     
 2005844:	c6 14 20 02 	lduh  [ %l0 + 2 ], %g3                         
    {                                                                 
      rtems_fdisk_error ("recycle: no available dst segment");        
      return EIO;                                                     
    }                                                                 
                                                                      
    if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
 2005848:	80 88 e0 01 	btst  1, %g3                                   
 200584c:	12 80 00 a8 	bne  2005aec <rtems_fdisk_recycle_segment+0x300><== NEVER TAKEN
 2005850:	80 88 e0 02 	btst  2, %g3                                   
 2005854:	02 80 00 a6 	be  2005aec <rtems_fdisk_recycle_segment+0x300>
 2005858:	ba 10 20 00 	clr  %i5                                       
 * Find the next available page in a segment.                         
 */                                                                   
static uint32_t                                                       
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)     
{                                                                     
  rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];               
 200585c:	e6 04 60 10 	ld  [ %l1 + 0x10 ], %l3                        
  uint32_t               page;                                        
                                                                      
  for (page = 0; page < sc->pages; page++, pd++)                      
 2005860:	10 80 00 08 	b  2005880 <rtems_fdisk_recycle_segment+0x94>  
 2005864:	e8 04 60 14 	ld  [ %l1 + 0x14 ], %l4                        
    if (rtems_fdisk_page_desc_erased (pd))                            
 2005868:	7f ff fd 35 	call  2004d3c <rtems_fdisk_page_desc_erased>   
 200586c:	01 00 00 00 	nop                                            
 2005870:	80 8a 20 ff 	btst  0xff, %o0                                
 2005874:	12 80 00 08 	bne  2005894 <rtems_fdisk_recycle_segment+0xa8>
 2005878:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
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++)                      
 200587c:	ba 07 60 01 	inc  %i5                                       
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
 2005880:	91 2f 60 03 	sll  %i5, 3, %o0                               
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++)                      
 2005884:	80 a7 40 14 	cmp  %i5, %l4                                  
 2005888:	12 bf ff f8 	bne  2005868 <rtems_fdisk_recycle_segment+0x7c><== ALWAYS TAKEN
 200588c:	90 04 c0 08 	add  %l3, %o0, %o0                             
      uint32_t               dpage;                                   
                                                                      
      dpage = rtems_fdisk_seg_next_available_page (dsc);              
      dpd   = &dsc->page_descriptors[dpage];                          
                                                                      
      active++;                                                       
 2005890:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== 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];                          
 2005894:	b3 2f 60 03 	sll  %i5, 3, %i1                               
                                                                      
      active++;                                                       
 2005898:	82 00 60 01 	inc  %g1                                       
 200589c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
      if (dpage >= dsc->pages)                                        
 20058a0:	80 a7 40 14 	cmp  %i5, %l4                                  
 20058a4:	0a 80 00 14 	bcs  20058f4 <rtems_fdisk_recycle_segment+0x108><== ALWAYS TAKEN
 20058a8:	b4 04 c0 19 	add  %l3, %i1, %i2                             
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
 20058ac:	7f ff fd 2e 	call  2004d64 <rtems_fdisk_seg_pages_available><== NOT EXECUTED
 20058b0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
 20058b4:	d2 04 60 08 	ld  [ %l1 + 8 ], %o1                           <== NOT EXECUTED
 20058b8:	d4 04 60 0c 	ld  [ %l1 + 0xc ], %o2                         <== NOT EXECUTED
 20058bc:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 20058c0:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 20058c4:	7f ff fd a2 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 20058c8:	90 12 22 18 	or  %o0, 0x218, %o0	! 2030e18 <__FUNCTION__.7127+0x740><== NOT EXECUTED
                           "no page desc available: %d",              
                           dsc->device, dsc->segment,                 
                           rtems_fdisk_seg_pages_available (dsc));    
        dsc->failed = true;                                           
 20058cc:	86 10 20 01 	mov  1, %g3                                    <== NOT EXECUTED
        rtems_fdisk_queue_segment (fd, dsc);                          
 20058d0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 20058d4:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
 20058d8:	7f ff fd fa 	call  20050c0 <rtems_fdisk_queue_segment>      <== NOT EXECUTED
 20058dc:	c6 24 60 28 	st  %g3, [ %l1 + 0x28 ]                        <== NOT EXECUTED
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
 20058e0:	90 06 20 40 	add  %i0, 0x40, %o0                            <== NOT EXECUTED
 20058e4:	7f ff fc 77 	call  2004ac0 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
 20058e8:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
        return EIO;                                                   
 20058ec:	10 80 00 9e 	b  2005b64 <rtems_fdisk_recycle_segment+0x378> <== NOT EXECUTED
 20058f0:	a8 10 20 05 	mov  5, %l4                                    <== NOT EXECUTED
      }                                                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
 20058f4:	da 04 60 08 	ld  [ %l1 + 8 ], %o5                           
 20058f8:	c6 04 60 0c 	ld  [ %l1 + 0xc ], %g3                         
 20058fc:	d4 05 60 08 	ld  [ %l5 + 8 ], %o2                           
 2005900:	d6 05 60 0c 	ld  [ %l5 + 0xc ], %o3                         
 2005904:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
 2005908:	98 10 00 1c 	mov  %i4, %o4                                  
 200590c:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
 2005910:	90 10 00 18 	mov  %i0, %o0                                  
 2005914:	13 00 80 c3 	sethi  %hi(0x2030c00), %o1                     
 2005918:	7f ff fd 2d 	call  2004dcc <rtems_fdisk_info>               
 200591c:	92 12 62 48 	or  %o1, 0x248, %o1	! 2030e48 <__FUNCTION__.7127+0x770>
                        ssc->device, ssc->segment, spage,             
                        dsc->device, dsc->segment, dpage);            
#endif                                                                
      ret = rtems_fdisk_seg_copy_page (fd, ssc,                       
 2005920:	c8 04 60 18 	ld  [ %l1 + 0x18 ], %g4                        
 2005924:	c6 05 60 18 	ld  [ %l5 + 0x18 ], %g3                        
                           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",
 2005928:	da 04 60 08 	ld  [ %l1 + 8 ], %o5                           
 200592c:	de 04 60 0c 	ld  [ %l1 + 0xc ], %o7                         
 2005930:	d4 05 60 08 	ld  [ %l5 + 8 ], %o2                           
 2005934:	d6 05 60 0c 	ld  [ %l5 + 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,                       
 2005938:	88 07 40 04 	add  %i5, %g4, %g4                             
 200593c:	86 07 00 03 	add  %i4, %g3, %g3                             
                           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",
 2005940:	c8 23 a0 60 	st  %g4, [ %sp + 0x60 ]                        
 2005944:	98 10 00 03 	mov  %g3, %o4                                  
 2005948:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
 200594c:	de 23 a0 5c 	st  %o7, [ %sp + 0x5c ]                        
 2005950:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
 2005954:	90 10 00 18 	mov  %i0, %o0                                  
 2005958:	13 00 80 c3 	sethi  %hi(0x2030c00), %o1                     
 200595c:	7f ff fd 3c 	call  2004e4c <rtems_fdisk_printf>             
 2005960:	92 12 62 70 	or  %o1, 0x270, %o1	! 2030e70 <__FUNCTION__.7127+0x798>
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,                                
 2005964:	c6 07 bf f4 	ld  [ %fp + -12 ], %g3                         
                               page * fd->block_size, buffer, fd->block_size);
 2005968:	e8 06 20 14 	ld  [ %i0 + 0x14 ], %l4                        
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,                                
 200596c:	90 10 00 03 	mov  %g3, %o0                                  
 2005970:	7f ff f3 09 	call  2002594 <.umul>                          
 2005974:	92 10 00 14 	mov  %l4, %o1                                  
 2005978:	d6 06 20 68 	ld  [ %i0 + 0x68 ], %o3                        
 200597c:	94 10 00 08 	mov  %o0, %o2                                  
 2005980:	98 10 00 14 	mov  %l4, %o4                                  
 2005984:	90 10 00 18 	mov  %i0, %o0                                  
 2005988:	7f ff fe 2b 	call  2005234 <rtems_fdisk_seg_read>           
 200598c:	92 10 00 15 	mov  %l5, %o1                                  
                      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)                                                            
 2005990:	a8 92 20 00 	orcc  %o0, 0, %l4                              
 2005994:	12 80 00 0a 	bne  20059bc <rtems_fdisk_recycle_segment+0x1d0><== NEVER TAKEN
 2005998:	c8 07 bf f0 	ld  [ %fp + -16 ], %g4                         
    return ret;                                                       
  return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,            
 200599c:	d6 06 20 68 	ld  [ %i0 + 0x68 ], %o3                        
 20059a0:	90 10 00 18 	mov  %i0, %o0                                  
 20059a4:	92 10 00 11 	mov  %l1, %o1                                  
 20059a8:	7f ff ff 76 	call  2005780 <rtems_fdisk_seg_write_page>     
 20059ac:	94 10 00 04 	mov  %g4, %o2                                  
#endif                                                                
      ret = rtems_fdisk_seg_copy_page (fd, ssc,                       
                                       spage + ssc->pages_desc,       
                                       dsc,                           
                                       dpage + dsc->pages_desc);      
      if (ret)                                                        
 20059b0:	a8 92 20 00 	orcc  %o0, 0, %l4                              
 20059b4:	22 80 00 0e 	be,a   20059ec <rtems_fdisk_recycle_segment+0x200><== ALWAYS TAKEN
 20059b8:	c6 05 c0 16 	ld  [ %l7 + %l6 ], %g3                         
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \              
 20059bc:	e0 05 60 08 	ld  [ %l5 + 8 ], %l0                           <== NOT EXECUTED
 20059c0:	f2 05 60 0c 	ld  [ %l5 + 0xc ], %i1                         <== NOT EXECUTED
 20059c4:	f4 04 60 08 	ld  [ %l1 + 8 ], %i2                           <== NOT EXECUTED
 20059c8:	f6 04 60 0c 	ld  [ %l1 + 0xc ], %i3                         <== NOT EXECUTED
 20059cc:	40 00 75 da 	call  2023134 <strerror>                       <== NOT EXECUTED
 20059d0:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
 20059d4:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        <== NOT EXECUTED
 20059d8:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        <== NOT EXECUTED
 20059dc:	e8 23 a0 64 	st  %l4, [ %sp + 0x64 ]                        <== NOT EXECUTED
 20059e0:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 20059e4:	10 80 00 17 	b  2005a40 <rtems_fdisk_recycle_segment+0x254> <== NOT EXECUTED
 20059e8:	90 12 22 a0 	or  %o0, 0x2a0, %o0	! 2030ea0 <__FUNCTION__.7127+0x7c8><== NOT EXECUTED
        return ret;                                                   
      }                                                               
                                                                      
      *dpd = *spd;                                                    
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
 20059ec:	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;                                                    
 20059f0:	c6 24 c0 19 	st  %g3, [ %l3 + %i1 ]                         
 20059f4:	c6 04 20 04 	ld  [ %l0 + 4 ], %g3                           
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
 20059f8:	92 10 00 11 	mov  %l1, %o1                                  
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      *dpd = *spd;                                                    
 20059fc:	c6 26 a0 04 	st  %g3, [ %i2 + 4 ]                           
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
 2005a00:	94 10 00 1d 	mov  %i5, %o2                                  
 2005a04:	7f ff fe 75 	call  20053d8 <rtems_fdisk_seg_write_page_desc>
 2005a08:	96 10 00 1a 	mov  %i2, %o3                                  
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
 2005a0c:	a8 92 20 00 	orcc  %o0, 0, %l4                              
 2005a10:	22 80 00 1a 	be,a   2005a78 <rtems_fdisk_recycle_segment+0x28c><== ALWAYS TAKEN
 2005a14:	c6 04 60 1c 	ld  [ %l1 + 0x1c ], %g3                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>"   \            
 2005a18:	e0 05 60 08 	ld  [ %l5 + 8 ], %l0                           <== NOT EXECUTED
 2005a1c:	f2 05 60 0c 	ld  [ %l5 + 0xc ], %i1                         <== NOT EXECUTED
 2005a20:	f4 04 60 08 	ld  [ %l1 + 8 ], %i2                           <== NOT EXECUTED
 2005a24:	40 00 75 c4 	call  2023134 <strerror>                       <== NOT EXECUTED
 2005a28:	f6 04 60 0c 	ld  [ %l1 + 0xc ], %i3                         <== NOT EXECUTED
 2005a2c:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        <== NOT EXECUTED
 2005a30:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        <== NOT EXECUTED
 2005a34:	e8 23 a0 64 	st  %l4, [ %sp + 0x64 ]                        <== NOT EXECUTED
 2005a38:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     <== NOT EXECUTED
 2005a3c:	90 12 22 e8 	or  %o0, 0x2e8, %o0	! 2030ee8 <__FUNCTION__.7127+0x810><== NOT EXECUTED
 2005a40:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 2005a44:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
 2005a48:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
 2005a4c:	98 10 00 1a 	mov  %i2, %o4                                  <== NOT EXECUTED
 2005a50:	7f ff fd 3f 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005a54:	9a 10 00 1b 	mov  %i3, %o5                                  <== 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);                          
 2005a58:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2005a5c:	7f ff fd 99 	call  20050c0 <rtems_fdisk_queue_segment>      <== NOT EXECUTED
 2005a60:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
 2005a64:	90 06 20 40 	add  %i0, 0x40, %o0                            <== NOT EXECUTED
 2005a68:	7f ff fc 16 	call  2004ac0 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
 2005a6c:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
        return ret;                                                   
 2005a70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2005a74:	91 e8 00 14 	restore  %g0, %l4, %o0                         <== NOT EXECUTED
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
 2005a78:	c8 06 20 18 	ld  [ %i0 + 0x18 ], %g4                        
        rtems_fdisk_queue_segment (fd, dsc);                          
        rtems_fdisk_segment_queue_push_head (&fd->used, ssc);         
        return ret;                                                   
      }                                                               
                                                                      
      dsc->pages_active++;                                            
 2005a7c:	86 00 e0 01 	inc  %g3                                       
 2005a80:	c6 24 60 1c 	st  %g3, [ %l1 + 0x1c ]                        
       * 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--;                                            
 2005a84:	c6 05 60 1c 	ld  [ %l5 + 0x1c ], %g3                        
      fd->blocks[spd->block].page    = dpage;                         
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, dsc);                            
 2005a88:	90 10 00 18 	mov  %i0, %o0                                  
       * 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--;                                            
 2005a8c:	86 00 ff ff 	add  %g3, -1, %g3                              
 2005a90:	c6 25 60 1c 	st  %g3, [ %l5 + 0x1c ]                        
      ssc->pages_used++;                                              
 2005a94:	c6 05 60 20 	ld  [ %l5 + 0x20 ], %g3                        
 2005a98:	86 00 e0 01 	inc  %g3                                       
 2005a9c:	c6 25 60 20 	st  %g3, [ %l5 + 0x20 ]                        
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
 2005aa0:	c6 04 20 04 	ld  [ %l0 + 4 ], %g3                           
 2005aa4:	87 28 e0 03 	sll  %g3, 3, %g3                               
 2005aa8:	9e 01 00 03 	add  %g4, %g3, %o7                             
 2005aac:	e2 21 00 03 	st  %l1, [ %g4 + %g3 ]                         
      fd->blocks[spd->block].page    = dpage;                         
 2005ab0:	fa 23 e0 04 	st  %i5, [ %o7 + 4 ]                           
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, dsc);                            
 2005ab4:	7f ff fd 83 	call  20050c0 <rtems_fdisk_queue_segment>      
 2005ab8:	92 10 00 11 	mov  %l1, %o1                                  
                                                                      
      /*                                                              
       * Get new destination segment if necessary.                    
       */                                                             
      dst_pages = rtems_fdisk_seg_pages_available (dsc);              
 2005abc:	7f ff fc aa 	call  2004d64 <rtems_fdisk_seg_pages_available>
 2005ac0:	90 10 00 11 	mov  %l1, %o0                                  
      if (dst_pages == 0)                                             
 2005ac4:	80 a2 20 00 	cmp  %o0, 0                                    
 2005ac8:	32 80 00 06 	bne,a   2005ae0 <rtems_fdisk_recycle_segment+0x2f4>
 2005acc:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
 2005ad0:	7f ff fc ad 	call  2004d84 <rtems_fdisk_seg_most_available> 
 2005ad4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
 2005ad8:	a2 10 00 08 	mov  %o0, %l1                                  
                                                                      
      (*pages)--;                                                     
 2005adc:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
 2005ae0:	86 00 ff ff 	add  %g3, -1, %g3                              
      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))
    {                                                                 
 2005ae4:	10 80 00 0a 	b  2005b0c <rtems_fdisk_recycle_segment+0x320> 
 2005ae8:	c6 26 c0 00 	st  %g3, [ %i3 ]                               
      if (dst_pages == 0)                                             
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
                                                                      
      (*pages)--;                                                     
    }                                                                 
    else if (rtems_fdisk_page_desc_erased (spd))                      
 2005aec:	7f ff fc 94 	call  2004d3c <rtems_fdisk_page_desc_erased>   
 2005af0:	90 10 00 10 	mov  %l0, %o0                                  
 2005af4:	80 8a 20 ff 	btst  0xff, %o0                                
 2005af8:	22 80 00 05 	be,a   2005b0c <rtems_fdisk_recycle_segment+0x320><== ALWAYS TAKEN
 2005afc:	a4 04 a0 01 	inc  %l2                                       
    {                                                                 
      --fd->erased_blocks;                                            
 2005b00:	c6 06 20 28 	ld  [ %i0 + 0x28 ], %g3                        <== NOT EXECUTED
 2005b04:	86 00 ff ff 	add  %g3, -1, %g3                              <== NOT EXECUTED
 2005b08:	c6 26 20 28 	st  %g3, [ %i0 + 0x28 ]                        <== NOT EXECUTED
  int      ret;                                                       
  uint32_t spage;                                                     
  uint32_t used = 0;                                                  
  uint32_t active = 0;                                                
                                                                      
  for (spage = 0; spage < ssc->pages; spage++)                        
 2005b0c:	b8 07 20 01 	inc  %i4                                       
 2005b10:	c6 05 60 14 	ld  [ %l5 + 0x14 ], %g3                        
 2005b14:	80 a7 00 03 	cmp  %i4, %g3                                  
 2005b18:	2a bf ff 3e 	bcs,a   2005810 <rtems_fdisk_recycle_segment+0x24>
 2005b1c:	ee 05 60 10 	ld  [ %l5 + 0x10 ], %l7                        
      used++;                                                         
    }                                                                 
  }                                                                   
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",      
 2005b20:	d4 05 60 08 	ld  [ %l5 + 8 ], %o2                           
 2005b24:	d6 05 60 0c 	ld  [ %l5 + 0xc ], %o3                         
 2005b28:	da 07 bf fc 	ld  [ %fp + -4 ], %o5                          
 2005b2c:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        
 2005b30:	90 10 00 18 	mov  %i0, %o0                                  
 2005b34:	13 00 80 c3 	sethi  %hi(0x2030c00), %o1                     
 2005b38:	98 10 00 1b 	mov  %i3, %o4                                  
 2005b3c:	7f ff fc c4 	call  2004e4c <rtems_fdisk_printf>             
 2005b40:	92 12 63 30 	or  %o1, 0x330, %o1                            
                      ssc->device, ssc->segment,                      
                      pages, active, used);                           
#endif                                                                
  if (ssc->pages_active != 0)                                         
 2005b44:	d2 05 60 1c 	ld  [ %l5 + 0x1c ], %o1                        
 2005b48:	80 a2 60 00 	cmp  %o1, 0                                    
 2005b4c:	02 80 00 04 	be  2005b5c <rtems_fdisk_recycle_segment+0x370><== ALWAYS TAKEN
 2005b50:	11 00 80 c3 	sethi  %hi(0x2030c00), %o0                     
  {                                                                   
    rtems_fdisk_error ("compacting: ssc pages not 0: %d",             
 2005b54:	7f ff fc fe 	call  2004f4c <rtems_fdisk_error>              <== NOT EXECUTED
 2005b58:	90 12 23 58 	or  %o0, 0x358, %o0	! 2030f58 <__FUNCTION__.7127+0x880><== NOT EXECUTED
                       ssc->pages_active);                            
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
 2005b5c:	7f ff fd 19 	call  2004fc0 <rtems_fdisk_erase_segment>      
 2005b60:	93 e8 00 15 	restore  %g0, %l5, %o1                         
                                                                      
  return ret;                                                         
}                                                                     
 2005b64:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
 2005b68:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2005b6c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02005340 <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) {
 2005340:	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;                                                
 2005344:	e0 06 60 08 	ld  [ %i1 + 8 ], %l0                           
  segment = sc->segment;                                              
 2005348:	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;            
 200534c:	85 2c 20 04 	sll  %l0, 4, %g2                               
 2005350:	83 2c 20 02 	sll  %l0, 2, %g1                               
 2005354:	82 20 80 01 	sub  %g2, %g1, %g1                             
 2005358:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
 200535c:	89 2f 60 06 	sll  %i5, 6, %g4                               
 2005360:	86 00 80 01 	add  %g2, %g1, %g3                             
 2005364:	c4 00 80 01 	ld  [ %g2 + %g1 ], %g2                         
 2005368:	83 2f 60 04 	sll  %i5, 4, %g1                               
 200536c:	82 21 00 01 	sub  %g4, %g1, %g1                             
 2005370:	82 00 80 01 	add  %g2, %g1, %g1                             
 2005374:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
  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;                    
 2005378:	c2 00 e0 08 	ld  [ %g3 + 8 ], %g1                           
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-write: %02d-%03d: o=%08x s=%d",      
 200537c:	90 10 00 18 	mov  %i0, %o0                                  
  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;                    
 2005380:	e4 00 60 08 	ld  [ %g1 + 8 ], %l2                           
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, "  seg-write: %02d-%03d: o=%08x s=%d",      
 2005384:	94 10 00 10 	mov  %l0, %o2                                  
 2005388:	96 10 00 1d 	mov  %i5, %o3                                  
 200538c:	98 10 00 1a 	mov  %i2, %o4                                  
 2005390:	9a 10 00 1c 	mov  %i4, %o5                                  
 2005394:	13 00 80 c3 	sethi  %hi(0x2030c00), %o1                     
 2005398:	7f ff fe ad 	call  2004e4c <rtems_fdisk_printf>             
 200539c:	92 12 60 b0 	or  %o1, 0xb0, %o1	! 2030cb0 <__FUNCTION__.7127+0x5d8>
                      device, segment, offset, size);                 
#endif                                                                
  ret = ops->write (sd, device, segment, offset, buffer, size);       
 20053a0:	c2 04 a0 04 	ld  [ %l2 + 4 ], %g1                           
 20053a4:	90 10 00 11 	mov  %l1, %o0                                  
 20053a8:	92 10 00 10 	mov  %l0, %o1                                  
 20053ac:	94 10 00 1d 	mov  %i5, %o2                                  
 20053b0:	96 10 00 1a 	mov  %i2, %o3                                  
 20053b4:	98 10 00 1b 	mov  %i3, %o4                                  
 20053b8:	9f c0 40 00 	call  %g1                                      
 20053bc:	9a 10 00 1c 	mov  %i4, %o5                                  
  if (ret)                                                            
 20053c0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20053c4:	02 80 00 03 	be  20053d0 <rtems_fdisk_seg_write+0x90>       <== ALWAYS TAKEN
 20053c8:	82 10 20 01 	mov  1, %g1                                    
    sc->failed = true;                                                
 20053cc:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
                                                                      
  return ret;                                                         
}                                                                     
 20053d0:	81 c7 e0 08 	ret                                            
 20053d4:	81 e8 00 00 	restore                                        
                                                                      

02005780 <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) {
 2005780:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
 2005784:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 2005788:	80 88 60 08 	btst  8, %g1                                   
 200578c:	32 80 00 0b 	bne,a   20057b8 <rtems_fdisk_seg_write_page+0x38><== ALWAYS TAKEN
 2005790:	fa 06 20 14 	ld  [ %i0 + 0x14 ], %i5                        
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);        
    if (ret)                                                          
      return ret;                                                     
  }                                                                   
  --fd->erased_blocks;                                                
 2005794:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  return rtems_fdisk_seg_write (fd, sc,                               
                                page * fd->block_size, buffer, fd->block_size);
 2005798:	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;                                                
 200579c:	82 00 7f ff 	add  %g1, -1, %g1                              
  return rtems_fdisk_seg_write (fd, sc,                               
 20057a0:	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;                                                
 20057a4:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  return rtems_fdisk_seg_write (fd, sc,                               
 20057a8:	7f ff f3 7b 	call  2002594 <.umul>                          
 20057ac:	92 10 00 1c 	mov  %i4, %o1                                  
 20057b0:	7f ff fe e4 	call  2005340 <rtems_fdisk_seg_write>          
 20057b4:	95 e8 00 08 	restore  %g0, %o0, %o2                         
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,                         
 20057b8:	90 10 00 1a 	mov  %i2, %o0                                  
 20057bc:	7f ff f3 76 	call  2002594 <.umul>                          
 20057c0:	92 10 00 1d 	mov  %i5, %o1                                  
 20057c4:	92 10 00 19 	mov  %i1, %o1                                  
 20057c8:	94 10 00 08 	mov  %o0, %o2                                  
 20057cc:	96 10 00 1d 	mov  %i5, %o3                                  
 20057d0:	7f ff fe bb 	call  20052bc <rtems_fdisk_seg_blank_check>    
 20057d4:	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)                                                          
 20057d8:	80 a2 20 00 	cmp  %o0, 0                                    
 20057dc:	22 bf ff ef 	be,a   2005798 <rtems_fdisk_seg_write_page+0x18><== ALWAYS TAKEN
 20057e0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
      return ret;                                                     
  }                                                                   
  --fd->erased_blocks;                                                
  return rtems_fdisk_seg_write (fd, sc,                               
                                page * fd->block_size, buffer, fd->block_size);
}                                                                     
 20057e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20057e8:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

020053d8 <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) {
 20053d8:	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))             
 20053dc:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 20053e0:	80 88 60 08 	btst  8, %g1                                   
 20053e4:	12 80 00 04 	bne  20053f4 <rtems_fdisk_seg_write_page_desc+0x1c><== ALWAYS TAKEN
 20053e8:	b5 2e a0 03 	sll  %i2, 3, %i2                               
                                           offset,                    
                                           sizeof (rtems_fdisk_page_desc));
    if (ret)                                                          
      return ret;                                                     
  }                                                                   
  return rtems_fdisk_seg_write (fd, sc, offset,                       
 20053ec:	7f ff ff d5 	call  2005340 <rtems_fdisk_seg_write>          
 20053f0:	99 e8 20 08 	restore  %g0, 8, %o4                           
                                 const rtems_fdisk_page_desc* page_desc)
{                                                                     
  uint32_t offset = page * sizeof (rtems_fdisk_page_desc);            
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check (fd, sc,                    
 20053f4:	90 10 00 18 	mov  %i0, %o0                                  
 20053f8:	92 10 00 19 	mov  %i1, %o1                                  
 20053fc:	94 10 00 1a 	mov  %i2, %o2                                  
 2005400:	7f ff ff af 	call  20052bc <rtems_fdisk_seg_blank_check>    
 2005404:	96 10 20 08 	mov  8, %o3                                    
                                           offset,                    
                                           sizeof (rtems_fdisk_page_desc));
    if (ret)                                                          
 2005408:	80 a2 20 00 	cmp  %o0, 0                                    
 200540c:	02 bf ff f8 	be  20053ec <rtems_fdisk_seg_write_page_desc+0x14><== ALWAYS TAKEN
 2005410:	01 00 00 00 	nop                                            
      return ret;                                                     
  }                                                                   
  return rtems_fdisk_seg_write (fd, sc, offset,                       
                                page_desc, sizeof (rtems_fdisk_page_desc));
}                                                                     
 2005414:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2005418:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

02004bf8 <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)
 2004bf8:	80 a2 60 00 	cmp  %o1, 0                                    
 2004bfc:	02 80 00 10 	be  2004c3c <rtems_fdisk_segment_queue_insert_before+0x44><== NEVER TAKEN
 2004c00:	84 10 00 08 	mov  %o0, %g2                                  
  {                                                                   
    rtems_fdisk_segment_ctl** prev = &queue->head;                    
    rtems_fdisk_segment_ctl*  it = queue->head;                       
                                                                      
    while (it)                                                        
 2004c04:	10 80 00 0b 	b  2004c30 <rtems_fdisk_segment_queue_insert_before+0x38>
 2004c08:	c2 02 00 00 	ld  [ %o0 ], %g1                               
    {                                                                 
      if (item == it)                                                 
 2004c0c:	32 80 00 08 	bne,a   2004c2c <rtems_fdisk_segment_queue_insert_before+0x34>
 2004c10:	84 10 00 01 	mov  %g1, %g2                                  
      {                                                               
        sc->next = item;                                              
 2004c14:	d2 22 80 00 	st  %o1, [ %o2 ]                               
        *prev = sc;                                                   
        queue->count++;                                               
 2004c18:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
    while (it)                                                        
    {                                                                 
      if (item == it)                                                 
      {                                                               
        sc->next = item;                                              
        *prev = sc;                                                   
 2004c1c:	d4 20 80 00 	st  %o2, [ %g2 ]                               
        queue->count++;                                               
 2004c20:	82 00 60 01 	inc  %g1                                       
        return;                                                       
 2004c24:	81 c3 e0 08 	retl                                           
 2004c28:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
      }                                                               
                                                                      
      prev = &it->next;                                               
      it = it->next;                                                  
 2004c2c:	c2 00 40 00 	ld  [ %g1 ], %g1                               
  if (item)                                                           
  {                                                                   
    rtems_fdisk_segment_ctl** prev = &queue->head;                    
    rtems_fdisk_segment_ctl*  it = queue->head;                       
                                                                      
    while (it)                                                        
 2004c30:	80 a0 60 00 	cmp  %g1, 0                                    
 2004c34:	12 bf ff f6 	bne  2004c0c <rtems_fdisk_segment_queue_insert_before+0x14><== ALWAYS TAKEN
 2004c38:	80 a2 40 01 	cmp  %o1, %g1                                  
      prev = &it->next;                                               
      it = it->next;                                                  
    }                                                                 
  }                                                                   
                                                                      
  rtems_fdisk_segment_queue_push_tail (queue, sc);                    
 2004c3c:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
 2004c40:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 2004c44:	7f ff ff be 	call  2004b3c <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
 2004c48:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

02004afc <rtems_fdisk_segment_queue_pop_head>: /** * 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) {
 2004afc:	82 10 00 08 	mov  %o0, %g1                                  
  if (queue->head)                                                    
 2004b00:	d0 02 00 00 	ld  [ %o0 ], %o0                               
 2004b04:	80 a2 20 00 	cmp  %o0, 0                                    
 2004b08:	02 80 00 0b 	be  2004b34 <rtems_fdisk_segment_queue_pop_head+0x38><== NEVER TAKEN
 2004b0c:	01 00 00 00 	nop                                            
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
 2004b10:	c4 02 00 00 	ld  [ %o0 ], %g2                               
    if (!queue->head)                                                 
 2004b14:	80 a0 a0 00 	cmp  %g2, 0                                    
 2004b18:	12 80 00 03 	bne  2004b24 <rtems_fdisk_segment_queue_pop_head+0x28>
 2004b1c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
      queue->tail = 0;                                                
 2004b20:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
                                                                      
    queue->count--;                                                   
 2004b24:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 2004b28:	84 00 bf ff 	add  %g2, -1, %g2                              
 2004b2c:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
                                                                      
    sc->next = 0;                                                     
 2004b30:	c0 22 00 00 	clr  [ %o0 ]                                   
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2004b34:	81 c3 e0 08 	retl                                           
                                                                      

02004ac0 <rtems_fdisk_segment_queue_push_head>: */ static void rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue, rtems_fdisk_segment_ctl* sc) { if (sc)
 2004ac0:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
 2004ac4:	02 80 00 0c 	be  2004af4 <rtems_fdisk_segment_queue_push_head+0x34><== NOT EXECUTED
 2004ac8:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    sc->next = queue->head;                                           
 2004acc:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
 2004ad0:	c2 22 40 00 	st  %g1, [ %o1 ]                               <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
 2004ad4:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           <== NOT EXECUTED
 2004ad8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2004adc:	12 80 00 03 	bne  2004ae8 <rtems_fdisk_segment_queue_push_head+0x28><== NOT EXECUTED
 2004ae0:	d2 22 00 00 	st  %o1, [ %o0 ]                               <== NOT EXECUTED
      queue->tail = sc;                                               
 2004ae4:	d2 22 20 04 	st  %o1, [ %o0 + 4 ]                           <== NOT EXECUTED
    queue->count++;                                                   
 2004ae8:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           <== NOT EXECUTED
 2004aec:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
 2004af0:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           <== NOT EXECUTED
 2004af4:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

02004b3c <rtems_fdisk_segment_queue_push_tail>: */ static void rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue, rtems_fdisk_segment_ctl* sc) { if (sc)
 2004b3c:	80 a2 60 00 	cmp  %o1, 0                                    
 2004b40:	02 80 00 0f 	be  2004b7c <rtems_fdisk_segment_queue_push_tail+0x40><== NEVER TAKEN
 2004b44:	01 00 00 00 	nop                                            
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
 2004b48:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 2004b4c:	80 a0 60 00 	cmp  %g1, 0                                    
 2004b50:	02 80 00 06 	be  2004b68 <rtems_fdisk_segment_queue_push_tail+0x2c>
 2004b54:	c0 22 40 00 	clr  [ %o1 ]                                   
    {                                                                 
      queue->tail->next = sc;                                         
 2004b58:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
 2004b5c:	d2 20 40 00 	st  %o1, [ %g1 ]                               
      queue->tail       = sc;                                         
 2004b60:	10 80 00 04 	b  2004b70 <rtems_fdisk_segment_queue_push_tail+0x34>
 2004b64:	d2 22 20 04 	st  %o1, [ %o0 + 4 ]                           
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
 2004b68:	d2 22 20 04 	st  %o1, [ %o0 + 4 ]                           
 2004b6c:	d2 22 00 00 	st  %o1, [ %o0 ]                               
    }                                                                 
                                                                      
    queue->count++;                                                   
 2004b70:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
 2004b74:	82 00 60 01 	inc  %g1                                       
 2004b78:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
 2004b7c:	81 c3 e0 08 	retl                                           
                                                                      

02004b84 <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;
 2004b84:	c2 02 00 00 	ld  [ %o0 ], %g1                               
                                                                      
  /*                                                                  
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
 2004b88:	10 80 00 17 	b  2004be4 <rtems_fdisk_segment_queue_remove+0x60>
 2004b8c:	84 10 20 00 	clr  %g2                                       
  {                                                                   
    if (sc == it)                                                     
 2004b90:	32 80 00 14 	bne,a   2004be0 <rtems_fdisk_segment_queue_remove+0x5c>
 2004b94:	84 10 00 01 	mov  %g1, %g2                                  
    {                                                                 
      if (prev == 0)                                                  
 2004b98:	80 a0 a0 00 	cmp  %g2, 0                                    
 2004b9c:	12 80 00 07 	bne  2004bb8 <rtems_fdisk_segment_queue_remove+0x34>
 2004ba0:	c2 02 40 00 	ld  [ %o1 ], %g1                               
      {                                                               
        queue->head = sc->next;                                       
        if (queue->head == 0)                                         
 2004ba4:	80 a0 60 00 	cmp  %g1, 0                                    
 2004ba8:	12 80 00 09 	bne  2004bcc <rtems_fdisk_segment_queue_remove+0x48>
 2004bac:	c2 22 00 00 	st  %g1, [ %o0 ]                               
          queue->tail = 0;                                            
 2004bb0:	10 80 00 07 	b  2004bcc <rtems_fdisk_segment_queue_remove+0x48>
 2004bb4:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
      }                                                               
      else                                                            
      {                                                               
        prev->next = sc->next;                                        
 2004bb8:	c2 20 80 00 	st  %g1, [ %g2 ]                               
        if (queue->tail == sc)                                        
 2004bbc:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
 2004bc0:	80 a0 40 09 	cmp  %g1, %o1                                  
 2004bc4:	22 80 00 02 	be,a   2004bcc <rtems_fdisk_segment_queue_remove+0x48><== ALWAYS TAKEN
 2004bc8:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
          queue->tail = prev;                                         
      }                                                               
      sc->next = 0;                                                   
      queue->count--;                                                 
 2004bcc:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
          queue->tail = prev;                                         
      }                                                               
      sc->next = 0;                                                   
 2004bd0:	c0 22 40 00 	clr  [ %o1 ]                                   
      queue->count--;                                                 
 2004bd4:	82 00 7f ff 	add  %g1, -1, %g1                              
      break;                                                          
 2004bd8:	81 c3 e0 08 	retl                                           
 2004bdc:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
    }                                                                 
                                                                      
    prev = it;                                                        
    it = it->next;                                                    
 2004be0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
                                                                      
  /*                                                                  
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
 2004be4:	80 a0 60 00 	cmp  %g1, 0                                    
 2004be8:	12 bf ff ea 	bne  2004b90 <rtems_fdisk_segment_queue_remove+0xc>
 2004bec:	80 a2 40 01 	cmp  %o1, %g1                                  
 2004bf0:	81 c3 e0 08 	retl                                           
                                                                      

02004ecc <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, ...) {
 2004ecc:	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);                                          
 2004ed0:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
 2004ed4:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
 2004ed8:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
 2004edc:	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)                                            
 2004ee0:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        <== NOT EXECUTED
 2004ee4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2004ee8:	02 80 00 17 	be  2004f44 <rtems_fdisk_warning+0x78>         <== NOT EXECUTED
 2004eec:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
 2004ef0:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            <== NOT EXECUTED
    fprintf (stdout, "fdisk:warning:");                               
 2004ef4:	3b 00 80 d7 	sethi  %hi(0x2035c00), %i5                     <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
 2004ef8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
    fprintf (stdout, "fdisk:warning:");                               
 2004efc:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004f00:	11 00 80 c2 	sethi  %hi(0x2030800), %o0                     <== NOT EXECUTED
 2004f04:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
 2004f08:	40 00 71 15 	call  202135c <fputs>                          <== NOT EXECUTED
 2004f0c:	90 12 23 80 	or  %o0, 0x380, %o0                            <== NOT EXECUTED
    ret =  vfprintf (stdout, format, args);                           
 2004f10:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004f14:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
 2004f18:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
 2004f1c:	40 00 93 5e 	call  2029c94 <vfprintf>                       <== NOT EXECUTED
 2004f20:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
 2004f24:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:warning:");                               
    ret =  vfprintf (stdout, format, args);                           
 2004f28:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
 2004f2c:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
 2004f30:	40 00 70 d7 	call  202128c <fputc>                          <== NOT EXECUTED
 2004f34:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
    fflush (stdout);                                                  
 2004f38:	c2 07 63 00 	ld  [ %i5 + 0x300 ], %g1                       <== NOT EXECUTED
 2004f3c:	40 00 6f bc 	call  2020e2c <fflush>                         <== NOT EXECUTED
 2004f40:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    va_end (args);                                                    
  }                                                                   
  return ret;                                                         
}                                                                     
 2004f44:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004f48:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200c304 <rtems_filesystem_check_access>: int eval_flags, mode_t node_mode, uid_t node_uid, gid_t node_gid ) {
 200c304:	9d e3 bf a0 	save  %sp, -96, %sp                            
  mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;                
  uid_t task_uid = geteuid();                                         
 200c308:	7f ff ff 05 	call  200bf1c <geteuid>                        
 200c30c:	b0 0e 20 07 	and  %i0, 7, %i0                               
                                                                      
  if (task_uid == 0 || task_uid == node_uid) {                        
 200c310:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 200c314:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 200c318:	80 a2 00 1a 	cmp  %o0, %i2                                  
 200c31c:	22 80 00 12 	be,a   200c364 <rtems_filesystem_check_access+0x60>
 200c320:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 200c324:	80 a2 20 00 	cmp  %o0, 0                                    
 200c328:	12 80 00 04 	bne  200c338 <rtems_filesystem_check_access+0x34>
 200c32c:	01 00 00 00 	nop                                            
    perm_flags <<= RTEMS_FS_USR_SHIFT;                                
 200c330:	10 80 00 0d 	b  200c364 <rtems_filesystem_check_access+0x60>
 200c334:	b1 2e 20 06 	sll  %i0, 6, %i0                               
  } else {                                                            
    gid_t task_gid = getegid();                                       
 200c338:	7f ff fe f5 	call  200bf0c <getegid>                        
 200c33c:	01 00 00 00 	nop                                            
                                                                      
    if (task_gid == 0 || task_gid == node_gid) {                      
 200c340:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 200c344:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 200c348:	80 a2 00 1b 	cmp  %o0, %i3                                  
 200c34c:	22 80 00 06 	be,a   200c364 <rtems_filesystem_check_access+0x60>
 200c350:	b1 2e 20 03 	sll  %i0, 3, %i0                               
 200c354:	80 a2 20 00 	cmp  %o0, 0                                    
 200c358:	32 80 00 04 	bne,a   200c368 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
 200c35c:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
      perm_flags <<= RTEMS_FS_GRP_SHIFT;                              
 200c360:	b1 2e 20 03 	sll  %i0, 3, %i0                               <== NOT EXECUTED
    } else {                                                          
      perm_flags <<= RTEMS_FS_OTH_SHIFT;                              
    }                                                                 
  }                                                                   
                                                                      
  return (perm_flags & node_mode) == perm_flags;                      
 200c364:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
}                                                                     
 200c368:	80 a0 00 18 	cmp  %g0, %i0                                  
 200c36c:	b0 60 3f ff 	subx  %g0, -1, %i0                             
 200c370:	81 c7 e0 08 	ret                                            
 200c374:	81 e8 00 00 	restore                                        
                                                                      

02004b68 <rtems_filesystem_do_unmount>: } void rtems_filesystem_do_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
 2004b68:	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 );
 2004b6c:	3b 00 80 75 	sethi  %hi(0x201d400), %i5                     
 2004b70:	d0 07 60 4c 	ld  [ %i5 + 0x4c ], %o0	! 201d44c <rtems_libio_semaphore>
 2004b74:	92 10 20 00 	clr  %o1                                       
 2004b78:	40 00 0a d3 	call  20076c4 <rtems_semaphore_obtain>         
 2004b7c:	94 10 20 00 	clr  %o2                                       
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 2004b80:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
 2004b84:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
 2004b88:	d0 07 60 4c 	ld  [ %i5 + 0x4c ], %o0                        
  next->previous = previous;                                          
 2004b8c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
 2004b90:	40 00 0b 16 	call  20077e8 <rtems_semaphore_release>        
 2004b94:	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);  
 2004b98:	40 00 00 4d 	call  2004ccc <rtems_filesystem_global_location_release>
 2004b9c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
  (*mt_entry->ops->fsunmount_me_h)(mt_entry);                         
 2004ba0:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 2004ba4:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        
 2004ba8:	9f c0 40 00 	call  %g1                                      
 2004bac:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if (mt_entry->unmount_task != 0) {                                  
 2004bb0:	d0 06 20 3c 	ld  [ %i0 + 0x3c ], %o0                        
 2004bb4:	80 a2 20 00 	cmp  %o0, 0                                    
 2004bb8:	02 80 00 09 	be  2004bdc <rtems_filesystem_do_unmount+0x74> <== NEVER TAKEN
 2004bbc:	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 ); 
 2004bc0:	40 00 0b 37 	call  200789c <rtems_event_system_send>        
 2004bc4:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
    rtems_status_code sc =                                            
      rtems_event_transient_send(mt_entry->unmount_task);             
    if (sc != RTEMS_SUCCESSFUL) {                                     
 2004bc8:	80 a2 20 00 	cmp  %o0, 0                                    
 2004bcc:	02 80 00 04 	be  2004bdc <rtems_filesystem_do_unmount+0x74> <== ALWAYS TAKEN
 2004bd0:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred(0xdeadbeef);                         
 2004bd4:	40 00 0c 99 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 2004bd8:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  free(mt_entry);                                                     
 2004bdc:	7f ff fa 75 	call  20035b0 <free>                           
 2004be0:	81 e8 00 00 	restore                                        
                                                                      

0200c3b0 <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 ) {
 200c3b0:	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);        
 200c3b4:	23 00 80 6e 	sethi  %hi(0x201b800), %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);       
 200c3b8:	3b 00 80 6c 	sethi  %hi(0x201b000), %i5                     
              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 =              
 200c3bc:	a0 06 20 18 	add  %i0, 0x18, %l0                            
            } else {                                                  
              /* This is the root file system */                      
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
 200c3c0:	a2 14 60 28 	or  %l1, 0x28, %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);       
 200c3c4:	ba 17 63 90 	or  %i5, 0x390, %i5                            
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char **token,                                                 
  size_t *tokenlen                                                    
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_next_token(ctx);                         
 200c3c8:	40 00 00 99 	call  200c62c <rtems_filesystem_eval_path_next_token>
 200c3cc:	90 10 00 18 	mov  %i0, %o0                                  
  *token = ctx->token;                                                
  *tokenlen = ctx->tokenlen;                                          
 200c3d0:	f8 06 20 0c 	ld  [ %i0 + 0xc ], %i4                         
    const char *token;                                                
    size_t tokenlen;                                                  
                                                                      
    rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
                                                                      
    if (tokenlen > 0) {                                               
 200c3d4:	80 a7 20 00 	cmp  %i4, 0                                    
 200c3d8:	02 80 00 54 	be  200c528 <rtems_filesystem_eval_path_generic+0x178>
 200c3dc:	f6 06 20 08 	ld  [ %i0 + 8 ], %i3                           
      if ((*config->is_directory)(ctx, arg)) {                        
 200c3e0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 200c3e4:	90 10 00 18 	mov  %i0, %o0                                  
 200c3e8:	9f c0 40 00 	call  %g1                                      
 200c3ec:	92 10 00 19 	mov  %i1, %o1                                  
 200c3f0:	80 8a 20 ff 	btst  0xff, %o0                                
 200c3f4:	02 80 00 75 	be  200c5c8 <rtems_filesystem_eval_path_generic+0x218>
 200c3f8:	80 a7 20 01 	cmp  %i4, 1                                    
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
 200c3fc:	12 80 00 06 	bne  200c414 <rtems_filesystem_eval_path_generic+0x64>
 200c400:	82 10 20 00 	clr  %g1                                       
 200c404:	c2 4e c0 00 	ldsb  [ %i3 ], %g1                             
 200c408:	82 18 60 2e 	xor  %g1, 0x2e, %g1                            
 200c40c:	80 a0 00 01 	cmp  %g0, %g1                                  
 200c410:	82 60 3f ff 	subx  %g0, -1, %g1                             
        if (rtems_filesystem_is_current_directory(token, tokenlen)) { 
 200c414:	80 a0 60 00 	cmp  %g1, 0                                    
 200c418:	02 80 00 0f 	be  200c454 <rtems_filesystem_eval_path_generic+0xa4>
 200c41c:	80 a7 20 02 	cmp  %i4, 2                                    
          if (rtems_filesystem_eval_path_has_path(ctx)) {             
 200c420:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 200c424:	80 a0 60 00 	cmp  %g1, 0                                    
 200c428:	22 80 00 04 	be,a   200c438 <rtems_filesystem_eval_path_generic+0x88>
 200c42c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
                ¤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);       
 200c430:	10 80 00 40 	b  200c530 <rtems_filesystem_eval_path_generic+0x180>
 200c434:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
          if (rtems_filesystem_eval_path_has_path(ctx)) {             
            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) {   
 200c438:	80 88 61 00 	btst  0x100, %g1                               
 200c43c:	32 80 00 04 	bne,a   200c44c <rtems_filesystem_eval_path_generic+0x9c>
 200c440:	90 10 00 18 	mov  %i0, %o0                                  
                ¤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);       
 200c444:	10 80 00 3b 	b  200c530 <rtems_filesystem_eval_path_generic+0x180>
 200c448:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
            int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
                                                                      
            if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {   
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            } else {                                                  
              rtems_filesystem_eval_path_error(ctx, EINVAL);          
 200c44c:	10 80 00 5b 	b  200c5b8 <rtems_filesystem_eval_path_generic+0x208>
 200c450:	92 10 20 16 	mov  0x16, %o1                                 
static inline bool rtems_filesystem_is_parent_directory(              
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 2 && token [0] == '.' && token [1] == '.';       
 200c454:	12 80 00 0a 	bne  200c47c <rtems_filesystem_eval_path_generic+0xcc>
 200c458:	82 10 20 00 	clr  %g1                                       
 200c45c:	c4 4e c0 00 	ldsb  [ %i3 ], %g2                             
 200c460:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
 200c464:	12 80 00 07 	bne  200c480 <rtems_filesystem_eval_path_generic+0xd0>
 200c468:	80 a0 60 00 	cmp  %g1, 0                                    
 200c46c:	c2 4e e0 01 	ldsb  [ %i3 + 1 ], %g1                         
 200c470:	82 18 60 2e 	xor  %g1, 0x2e, %g1                            
 200c474:	80 a0 00 01 	cmp  %g0, %g1                                  
 200c478:	82 60 3f ff 	subx  %g0, -1, %g1                             
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;       
            }                                                         
          }                                                           
        } else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
 200c47c:	80 a0 60 00 	cmp  %g1, 0                                    
 200c480:	22 80 00 36 	be,a   200c558 <rtems_filesystem_eval_path_generic+0x1a8>
 200c484:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
  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;
 200c488:	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;
 200c48c:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        
  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 );           
 200c490:	c4 02 60 14 	ld  [ %o1 + 0x14 ], %g2                        
 200c494:	80 a0 40 02 	cmp  %g1, %g2                                  
 200c498:	12 80 00 07 	bne  200c4b4 <rtems_filesystem_eval_path_generic+0x104>
 200c49c:	90 10 20 00 	clr  %o0                                       
 200c4a0:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 200c4a4:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
 200c4a8:	9f c0 40 00 	call  %g1                                      
 200c4ac:	90 10 00 10 	mov  %l0, %o0                                  
 200c4b0:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
          }                                                           
        } else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
          rtems_filesystem_location_info_t *currentloc =              
            rtems_filesystem_eval_path_get_currentloc( ctx );         
                                                                      
          if (is_eval_path_root(ctx, currentloc)) {                   
 200c4b4:	80 8a 20 01 	btst  1, %o0                                   
 200c4b8:	22 80 00 04 	be,a   200c4c8 <rtems_filesystem_eval_path_generic+0x118>
 200c4bc:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        
                ¤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);       
 200c4c0:	10 80 00 1c 	b  200c530 <rtems_filesystem_eval_path_generic+0x180>
 200c4c4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %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 );      
 200c4c8:	90 10 00 10 	mov  %l0, %o0                                  
 200c4cc:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 200c4d0:	c4 00 a0 10 	ld  [ %g2 + 0x10 ], %g2                        
 200c4d4:	9f c0 80 00 	call  %g2                                      
 200c4d8:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
            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)) {                        
 200c4dc:	80 8a 20 ff 	btst  0xff, %o0                                
 200c4e0:	22 80 00 19 	be,a   200c544 <rtems_filesystem_eval_path_generic+0x194>
 200c4e4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
            if (currentloc->mt_entry->mt_point_node != NULL) {        
 200c4e8:	d2 06 20 2c 	ld  [ %i0 + 0x2c ], %o1                        
 200c4ec:	c2 02 60 20 	ld  [ %o1 + 0x20 ], %g1                        
 200c4f0:	80 a0 60 00 	cmp  %g1, 0                                    
 200c4f4:	22 80 00 0f 	be,a   200c530 <rtems_filesystem_eval_path_generic+0x180><== NEVER TAKEN
 200c4f8:	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;                                    
 200c4fc:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
                                                                      
  ctx->path -= tokenlen;                                              
 200c500:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  ctx->pathlen += tokenlen;                                           
  ctx->tokenlen = 0;                                                  
 200c504:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
 200c508:	84 20 80 01 	sub  %g2, %g1, %g2                             
 200c50c:	c4 26 00 00 	st  %g2, [ %i0 ]                               
  ctx->pathlen += tokenlen;                                           
 200c510:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
              rtems_filesystem_eval_path_put_back_token(ctx);         
              rtems_filesystem_eval_path_restart(                     
 200c514:	90 10 00 18 	mov  %i0, %o0                                  
 200c518:	82 00 80 01 	add  %g2, %g1, %g1                             
 200c51c:	92 02 60 20 	add  %o1, 0x20, %o1                            
 200c520:	7f ff e1 1b 	call  200498c <rtems_filesystem_eval_path_restart>
 200c524:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
 200c528:	81 c7 e0 08 	ret                                            
 200c52c:	81 e8 00 00 	restore                                        
                ¤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);       
 200c530:	90 10 00 18 	mov  %i0, %o0                                  
 200c534:	92 10 00 19 	mov  %i1, %o1                                  
 200c538:	94 10 00 1d 	mov  %i5, %o2                                  
 200c53c:	10 80 00 0b 	b  200c568 <rtems_filesystem_eval_path_generic+0x1b8>
 200c540:	96 10 20 01 	mov  1, %o3                                    
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
 200c544:	90 10 00 18 	mov  %i0, %o0                                  
 200c548:	92 10 00 19 	mov  %i1, %o1                                  
 200c54c:	94 10 00 11 	mov  %l1, %o2                                  
 200c550:	10 80 00 06 	b  200c568 <rtems_filesystem_eval_path_generic+0x1b8>
 200c554:	96 10 20 02 	mov  2, %o3                                    
          }                                                           
        } else {                                                      
          status = (*config->eval_token)(ctx, arg, token, tokenlen);  
 200c558:	90 10 00 18 	mov  %i0, %o0                                  
 200c55c:	92 10 00 19 	mov  %i1, %o1                                  
 200c560:	94 10 00 1b 	mov  %i3, %o2                                  
 200c564:	96 10 00 1c 	mov  %i4, %o3                                  
 200c568:	9f c0 40 00 	call  %g1                                      
 200c56c:	01 00 00 00 	nop                                            
        }                                                             
                                                                      
        if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {  
 200c570:	80 a2 20 02 	cmp  %o0, 2                                    
 200c574:	12 80 00 18 	bne  200c5d4 <rtems_filesystem_eval_path_generic+0x224>
 200c578:	80 a2 20 00 	cmp  %o0, 0                                    
          if (rtems_filesystem_eval_path_has_path(ctx)) {             
 200c57c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 200c580:	80 a0 60 00 	cmp  %g1, 0                                    
 200c584:	02 80 00 16 	be  200c5dc <rtems_filesystem_eval_path_generic+0x22c>
 200c588:	01 00 00 00 	nop                                            
            int eval_flags;                                           
                                                                      
            rtems_filesystem_eval_path_eat_delimiter(ctx);            
 200c58c:	40 00 00 16 	call  200c5e4 <rtems_filesystem_eval_path_eat_delimiter>
 200c590:	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 
 200c594:	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 (                                                      
 200c598:	80 88 60 80 	btst  0x80, %g1                                
 200c59c:	02 80 00 06 	be  200c5b4 <rtems_filesystem_eval_path_generic+0x204>
 200c5a0:	90 10 00 18 	mov  %i0, %o0                                  
              (eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0 
                || rtems_filesystem_eval_path_has_path(ctx)           
 200c5a4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 200c5a8:	80 a0 60 00 	cmp  %g1, 0                                    
 200c5ac:	02 80 00 0c 	be  200c5dc <rtems_filesystem_eval_path_generic+0x22c>
 200c5b0:	01 00 00 00 	nop                                            
            ) {                                                       
              rtems_filesystem_eval_path_error(ctx, ENOENT);          
 200c5b4:	92 10 20 02 	mov  2, %o1	! 2 <PROM_START+0x2>               
 200c5b8:	7f ff e0 10 	call  20045f8 <rtems_filesystem_eval_path_error>
 200c5bc:	01 00 00 00 	nop                                            
 200c5c0:	81 c7 e0 08 	ret                                            
 200c5c4:	81 e8 00 00 	restore                                        
            }                                                         
          }                                                           
        }                                                             
      } else {                                                        
        rtems_filesystem_eval_path_error(ctx, ENOTDIR);               
 200c5c8:	90 10 00 18 	mov  %i0, %o0                                  
 200c5cc:	10 bf ff fb 	b  200c5b8 <rtems_filesystem_eval_path_generic+0x208>
 200c5d0:	92 10 20 14 	mov  0x14, %o1                                 
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
    RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;                      
                                                                      
  while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {     
 200c5d4:	02 bf ff 7d 	be  200c3c8 <rtems_filesystem_eval_path_generic+0x18>
 200c5d8:	01 00 00 00 	nop                                            
 200c5dc:	81 c7 e0 08 	ret                                            
 200c5e0:	81 e8 00 00 	restore                                        
                                                                      

020049f0 <rtems_filesystem_eval_path_recursive>: void rtems_filesystem_eval_path_recursive( rtems_filesystem_eval_path_context_t *ctx, const char *path, size_t pathlen ) {
 20049f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (pathlen > 0) {                                                  
 20049f4:	80 a6 a0 00 	cmp  %i2, 0                                    
 20049f8:	02 80 00 26 	be  2004a90 <rtems_filesystem_eval_path_recursive+0xa0><== NEVER TAKEN
 20049fc:	ba 10 00 18 	mov  %i0, %i5                                  
    if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {         
 2004a00:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 2004a04:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
 2004a08:	34 80 00 23 	bg,a   2004a94 <rtems_filesystem_eval_path_recursive+0xa4>
 2004a0c:	b2 10 20 5c 	mov  0x5c, %i1                                 
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
 2004a10:	c2 4e 40 00 	ldsb  [ %i1 ], %g1                             
      const char *saved_path = ctx->path;                             
 2004a14:	f6 06 00 00 	ld  [ %i0 ], %i3                               
      size_t saved_pathlen = ctx->pathlen;                            
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
 2004a18:	80 a0 60 5c 	cmp  %g1, 0x5c                                 
 2004a1c:	02 80 00 05 	be  2004a30 <rtems_filesystem_eval_path_recursive+0x40><== NEVER TAKEN
 2004a20:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           
 2004a24:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
 2004a28:	32 80 00 06 	bne,a   2004a40 <rtems_filesystem_eval_path_recursive+0x50>
 2004a2c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
        rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);       
 2004a30:	90 10 00 1d 	mov  %i5, %o0                                  
 2004a34:	7f ff ff d6 	call  200498c <rtems_filesystem_eval_path_restart>
 2004a38:	92 07 60 30 	add  %i5, 0x30, %o1                            
      }                                                               
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
 2004a3c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
        rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);       
      }                                                               
                                                                      
      ctx->path = path;                                               
 2004a40:	f2 27 40 00 	st  %i1, [ %i5 ]                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
 2004a44:	82 00 60 01 	inc  %g1                                       
      if (rtems_filesystem_is_delimiter(path [0])) {                  
        rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);       
      }                                                               
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
 2004a48:	f4 27 60 04 	st  %i2, [ %i5 + 4 ]                           
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
 2004a4c:	10 80 00 06 	b  2004a64 <rtems_filesystem_eval_path_recursive+0x74>
 2004a50:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
 2004a54:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2004a58:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 2004a5c:	9f c0 40 00 	call  %g1                                      
 2004a60:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
 2004a64:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 2004a68:	80 a0 60 00 	cmp  %g1, 0                                    
 2004a6c:	32 bf ff fa 	bne,a   2004a54 <rtems_filesystem_eval_path_recursive+0x64>
 2004a70:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
 2004a74:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
      ctx->path = saved_path;                                         
 2004a78:	f6 27 40 00 	st  %i3, [ %i5 ]                               
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
 2004a7c:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
      ctx->path = saved_path;                                         
      ctx->pathlen = saved_pathlen;                                   
 2004a80:	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;                                          
 2004a84:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
 2004a88:	81 c7 e0 08 	ret                                            
 2004a8c:	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);                    
 2004a90:	b2 10 20 02 	mov  2, %i1                                    <== NOT EXECUTED
 2004a94:	7f ff fe d9 	call  20045f8 <rtems_filesystem_eval_path_error>
 2004a98:	81 e8 00 00 	restore                                        
                                                                      

02004868 <rtems_filesystem_eval_path_start_with_parent>: const char *path, int eval_flags, rtems_filesystem_location_info_t *parentloc, int parent_eval_flags ) {
 2004868:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t pathlen = strlen(path);                                      
 200486c:	40 00 31 07 	call  2010c88 <strlen>                         
 2004870:	90 10 00 19 	mov  %i1, %o0                                  
 2004874:	10 80 00 09 	b  2004898 <rtems_filesystem_eval_path_start_with_parent+0x30>
 2004878:	94 10 00 08 	mov  %o0, %o2                                  
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
 200487c:	c4 4e 40 01 	ldsb  [ %i1 + %g1 ], %g2                       
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])) {                    
 2004880:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
 2004884:	02 80 00 28 	be  2004924 <rtems_filesystem_eval_path_start_with_parent+0xbc><== NEVER TAKEN
 2004888:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
 200488c:	02 80 00 27 	be  2004928 <rtems_filesystem_eval_path_start_with_parent+0xc0>
 2004890:	80 a2 20 00 	cmp  %o0, 0                                    
      return pathlen;                                                 
    }                                                                 
                                                                      
    pathlen = i;                                                      
 2004894:	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) {                                               
 2004898:	80 a2 a0 00 	cmp  %o2, 0                                    
 200489c:	12 bf ff f8 	bne  200487c <rtems_filesystem_eval_path_start_with_parent+0x14>
 20048a0:	82 02 bf ff 	add  %o2, -1, %g1                              
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
  size_t namelen = 0;                                                 
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
 20048a4:	80 a2 20 00 	cmp  %o0, 0                                    
 20048a8:	02 80 00 0a 	be  20048d0 <rtems_filesystem_eval_path_start_with_parent+0x68>
 20048ac:	ba 10 00 19 	mov  %i1, %i5                                  
 20048b0:	a0 10 00 08 	mov  %o0, %l0                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
 20048b4:	33 00 80 6c 	sethi  %hi(0x201b000), %i1                     
      parentpathlen = 1;                                              
 20048b8:	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 = ".";                                               
 20048bc:	10 80 00 09 	b  20048e0 <rtems_filesystem_eval_path_start_with_parent+0x78>
 20048c0:	92 16 63 90 	or  %i1, 0x390, %o1                            
      parentpathlen = 1;                                              
      name = path;                                                    
      namelen = pathlen;                                              
    } else {                                                          
      name = path + parentpathlen;                                    
      namelen = pathlen - parentpathlen;                              
 20048c4:	a0 22 00 0a 	sub  %o0, %o2, %l0                             
  rtems_filesystem_location_info_t *parentloc,                        
  int parent_eval_flags                                               
)                                                                     
{                                                                     
  size_t pathlen = strlen(path);                                      
  const char *parentpath = path;                                      
 20048c8:	10 80 00 06 	b  20048e0 <rtems_filesystem_eval_path_start_with_parent+0x78>
 20048cc:	92 10 00 19 	mov  %i1, %o1                                  
 20048d0:	92 10 00 19 	mov  %i1, %o1                                  
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
  size_t namelen = 0;                                                 
 20048d4:	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;                                            
 20048d8:	ba 10 20 00 	clr  %i5                                       
    }                                                                 
                                                                      
    pathlen = i;                                                      
  }                                                                   
                                                                      
  return 0;                                                           
 20048dc:	94 10 20 00 	clr  %o2                                       
  currentloc = eval_path_start(                                       
    ctx,                                                              
    parentpath,                                                       
    parentpathlen,                                                    
    parent_eval_flags,                                                
    &rtems_filesystem_root,                                           
 20048e0:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 20048e4:	da 00 62 e8 	ld  [ %g1 + 0x2e8 ], %o5	! 201cae8 <rtems_current_user_env>
      name = path + parentpathlen;                                    
      namelen = pathlen - parentpathlen;                              
    }                                                                 
  }                                                                   
                                                                      
  currentloc = eval_path_start(                                       
 20048e8:	96 10 00 1c 	mov  %i4, %o3                                  
 20048ec:	98 03 60 04 	add  %o5, 4, %o4                               
 20048f0:	7f ff ff 94 	call  2004740 <eval_path_start>                
 20048f4:	90 10 00 18 	mov  %i0, %o0                                  
 20048f8:	92 10 00 08 	mov  %o0, %o1                                  
    parent_eval_flags,                                                
    &rtems_filesystem_root,                                           
    &rtems_filesystem_current                                         
  );                                                                  
                                                                      
  rtems_filesystem_location_clone(parentloc, currentloc);             
 20048fc:	40 00 1d 3b 	call  200bde8 <rtems_filesystem_location_clone>
 2004900:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  ctx->path = name;                                                   
  ctx->pathlen = namelen;                                             
  ctx->flags = eval_flags;                                            
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
 2004904:	90 10 00 18 	mov  %i0, %o0                                  
    &rtems_filesystem_current                                         
  );                                                                  
                                                                      
  rtems_filesystem_location_clone(parentloc, currentloc);             
                                                                      
  ctx->path = name;                                                   
 2004908:	fa 26 00 00 	st  %i5, [ %i0 ]                               
  ctx->pathlen = namelen;                                             
 200490c:	e0 26 20 04 	st  %l0, [ %i0 + 4 ]                           
  ctx->flags = eval_flags;                                            
 2004910:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
 2004914:	7f ff ff 71 	call  20046d8 <rtems_filesystem_eval_path_continue>
 2004918:	b0 06 20 18 	add  %i0, 0x18, %i0                            
 200491c:	81 c7 e0 08 	ret                                            
 2004920:	81 e8 00 00 	restore                                        
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
  size_t namelen = 0;                                                 
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
 2004924:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2004928:	32 bf ff e7 	bne,a   20048c4 <rtems_filesystem_eval_path_start_with_parent+0x5c><== ALWAYS TAKEN
 200492c:	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;                                      
 2004930:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
  size_t namelen = 0;                                                 
 2004934:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
)                                                                     
{                                                                     
  size_t pathlen = strlen(path);                                      
  const char *parentpath = path;                                      
  size_t parentpathlen = get_parentpathlen(path, pathlen);            
  const char *name = NULL;                                            
 2004938:	10 bf ff ea 	b  20048e0 <rtems_filesystem_eval_path_start_with_parent+0x78><== NOT EXECUTED
 200493c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      

0200c16c <rtems_filesystem_get_mount_handler>: rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) {
 200c16c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  find_arg fa = {                                                     
 200c170:	f0 27 bf f8 	st  %i0, [ %fp + -8 ]                          
    .type = type,                                                     
    .mount_h = NULL                                                   
  };                                                                  
                                                                      
  if ( type != NULL ) {                                               
 200c174:	80 a6 20 00 	cmp  %i0, 0                                    
 200c178:	02 80 00 06 	be  200c190 <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
 200c17c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    rtems_filesystem_iterate( find_handler, &fa );                    
 200c180:	11 00 80 30 	sethi  %hi(0x200c000), %o0                     
 200c184:	92 07 bf f8 	add  %fp, -8, %o1                              
 200c188:	7f ff ff ce 	call  200c0c0 <rtems_filesystem_iterate>       
 200c18c:	90 12 20 5c 	or  %o0, 0x5c, %o0                             
  }                                                                   
                                                                      
  return fa.mount_h;                                                  
}                                                                     
 200c190:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
 200c194:	81 c7 e0 08 	ret                                            
 200c198:	81 e8 00 00 	restore                                        
                                                                      

0200327c <rtems_filesystem_initialize>: /* * Default mode for created files. */ void rtems_filesystem_initialize( void ) {
 200327c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  const rtems_filesystem_mount_configuration *root_config =           
    &rtems_filesystem_root_configuration;                             
                                                                      
  rv = mount(                                                         
 2003280:	05 00 80 69 	sethi  %hi(0x201a400), %g2                     
 2003284:	82 10 a3 c4 	or  %g2, 0x3c4, %g1	! 201a7c4 <rtems_filesystem_root_configuration>
 2003288:	d0 00 a3 c4 	ld  [ %g2 + 0x3c4 ], %o0                       
 200328c:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           
 2003290:	d4 00 60 08 	ld  [ %g1 + 8 ], %o2                           
 2003294:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         
 2003298:	40 00 02 21 	call  2003b1c <mount>                          
 200329c:	d8 00 60 10 	ld  [ %g1 + 0x10 ], %o4                        
    root_config->target,                                              
    root_config->filesystemtype,                                      
    root_config->options,                                             
    root_config->data                                                 
  );                                                                  
  if ( rv != 0 )                                                      
 20032a0:	80 a2 20 00 	cmp  %o0, 0                                    
 20032a4:	22 80 00 05 	be,a   20032b8 <rtems_filesystem_initialize+0x3c><== ALWAYS TAKEN
 20032a8:	11 00 80 6b 	sethi  %hi(0x201ac00), %o0                     
    rtems_fatal_error_occurred( 0xABCD0002 );                         
 20032ac:	11 2a f3 40 	sethi  %hi(0xabcd0000), %o0                    <== NOT EXECUTED
 20032b0:	10 80 00 09 	b  20032d4 <rtems_filesystem_initialize+0x58>  <== NOT EXECUTED
 20032b4:	90 12 20 02 	or  %o0, 2, %o0	! abcd0002 <RAM_END+0xa98d0002><== NOT EXECUTED
   *                                                                  
   *  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);                                          
 20032b8:	92 10 21 ff 	mov  0x1ff, %o1                                
 20032bc:	40 00 01 d0 	call  20039fc <mkdir>                          
 20032c0:	90 12 22 18 	or  %o0, 0x218, %o0                            
  if ( rv != 0 )                                                      
 20032c4:	80 a2 20 00 	cmp  %o0, 0                                    
 20032c8:	02 80 00 05 	be  20032dc <rtems_filesystem_initialize+0x60> <== ALWAYS TAKEN
 20032cc:	11 2a f3 40 	sethi  %hi(0xabcd0000), %o0                    
    rtems_fatal_error_occurred( 0xABCD0003 );                         
 20032d0:	90 12 20 03 	or  %o0, 3, %o0	! abcd0003 <RAM_END+0xa98d0003><== NOT EXECUTED
 20032d4:	40 00 12 d9 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 20032d8:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20032dc:	81 c7 e0 08 	ret                                            
 20032e0:	81 e8 00 00 	restore                                        
                                                                      

0200c0c0 <rtems_filesystem_iterate>: bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) {
 200c0c0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
 200c0c4:	39 00 80 69 	sethi  %hi(0x201a400), %i4                     
  rtems_chain_node *node = NULL;                                      
  bool stop = false;                                                  
 200c0c8:	ba 10 20 00 	clr  %i5                                       
                                                                      
  while ( table_entry->type && !stop ) {                              
 200c0cc:	10 80 00 06 	b  200c0e4 <rtems_filesystem_iterate+0x24>     
 200c0d0:	b8 17 23 d8 	or  %i4, 0x3d8, %i4                            
    stop = (*routine)( table_entry, routine_arg );                    
 200c0d4:	92 10 00 19 	mov  %i1, %o1                                  
 200c0d8:	9f c6 00 00 	call  %i0                                      
 200c0dc:	b8 07 20 08 	add  %i4, 8, %i4                               
 200c0e0:	ba 10 00 08 	mov  %o0, %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 ) {                              
 200c0e4:	c2 07 00 00 	ld  [ %i4 ], %g1                               
 200c0e8:	80 a0 60 00 	cmp  %g1, 0                                    
 200c0ec:	02 80 00 08 	be  200c10c <rtems_filesystem_iterate+0x4c>    
 200c0f0:	82 0f 60 ff 	and  %i5, 0xff, %g1                            
 200c0f4:	80 a0 60 00 	cmp  %g1, 0                                    
 200c0f8:	02 bf ff f7 	be  200c0d4 <rtems_filesystem_iterate+0x14>    
 200c0fc:	90 10 00 1c 	mov  %i4, %o0                                  
 200c100:	b0 0f 60 ff 	and  %i5, 0xff, %i0                            
 200c104:	81 c7 e0 08 	ret                                            
 200c108:	81 e8 00 00 	restore                                        
    stop = (*routine)( table_entry, routine_arg );                    
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
 200c10c:	80 a0 60 00 	cmp  %g1, 0                                    
 200c110:	32 80 00 15 	bne,a   200c164 <rtems_filesystem_iterate+0xa4>
 200c114:	b0 0f 60 ff 	and  %i5, 0xff, %i0                            
    rtems_libio_lock();                                               
 200c118:	7f ff ff de 	call  200c090 <rtems_libio_lock>               
 200c11c:	37 00 80 72 	sethi  %hi(0x201c800), %i3                     
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
 200c120:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 200c124:	f8 00 63 98 	ld  [ %g1 + 0x398 ], %i4	! 201cb98 <filesystem_chain>
    for (                                                             
 200c128:	10 80 00 06 	b  200c140 <rtems_filesystem_iterate+0x80>     
 200c12c:	b6 16 e3 9c 	or  %i3, 0x39c, %i3                            
      !rtems_chain_is_tail( &filesystem_chain, node ) && !stop;       
      node = rtems_chain_next( node )                                 
    ) {                                                               
      const filesystem_node *fsn = (filesystem_node *) node;          
                                                                      
      stop = (*routine)( &fsn->entry, routine_arg );                  
 200c130:	9f c6 00 00 	call  %i0                                      
 200c134:	92 10 00 19 	mov  %i1, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
 200c138:	f8 07 00 00 	ld  [ %i4 ], %i4                               
 200c13c:	ba 10 00 08 	mov  %o0, %i5                                  
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
    rtems_libio_lock();                                               
    for (                                                             
 200c140:	80 a7 00 1b 	cmp  %i4, %i3                                  
 200c144:	12 80 00 05 	bne  200c158 <rtems_filesystem_iterate+0x98>   
 200c148:	80 8f 60 ff 	btst  0xff, %i5                                
    ) {                                                               
      const filesystem_node *fsn = (filesystem_node *) node;          
                                                                      
      stop = (*routine)( &fsn->entry, routine_arg );                  
    }                                                                 
    rtems_libio_unlock();                                             
 200c14c:	7f ff ff d8 	call  200c0ac <rtems_libio_unlock>             
 200c150:	b0 0f 60 ff 	and  %i5, 0xff, %i0                            
 200c154:	30 80 00 04 	b,a   200c164 <rtems_filesystem_iterate+0xa4>  
                                                                      
  if ( !stop ) {                                                      
    rtems_libio_lock();                                               
    for (                                                             
      node = rtems_chain_first( &filesystem_chain );                  
      !rtems_chain_is_tail( &filesystem_chain, node ) && !stop;       
 200c158:	02 bf ff f6 	be  200c130 <rtems_filesystem_iterate+0x70>    <== ALWAYS TAKEN
 200c15c:	90 07 20 08 	add  %i4, 8, %o0                               
 200c160:	30 bf ff fb 	b,a   200c14c <rtems_filesystem_iterate+0x8c>  <== NOT EXECUTED
    }                                                                 
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  return stop;                                                        
}                                                                     
 200c164:	81 c7 e0 08 	ret                                            
 200c168:	81 e8 00 00 	restore                                        
                                                                      

02004be4 <rtems_filesystem_location_remove_from_mt_entry>: } void rtems_filesystem_location_remove_from_mt_entry( rtems_filesystem_location_info_t *loc ) {
 2004be4:	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);                       
 2004be8:	7f ff f6 77 	call  20025c4 <sparc_disable_interrupts>       
 2004bec:	01 00 00 00 	nop                                            
 2004bf0:	b8 10 00 08 	mov  %o0, %i4                                  
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
 2004bf4:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
 2004bf8:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
  rtems_chain_extract_unprotected(&loc->mt_entry_node);               
  do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);  
 2004bfc:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
  next->previous = previous;                                          
 2004c00:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
 2004c04:	7f ff ff a6 	call  2004a9c <rtems_filesystem_is_ready_for_unmount>
 2004c08:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 2004c0c:	ba 10 00 08 	mov  %o0, %i5                                  
  rtems_filesystem_mt_entry_unlock(lock_context);                     
 2004c10:	7f ff f6 71 	call  20025d4 <sparc_enable_interrupts>        
 2004c14:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  if (do_unmount) {                                                   
 2004c18:	80 8f 60 ff 	btst  0xff, %i5                                
 2004c1c:	02 80 00 05 	be  2004c30 <rtems_filesystem_location_remove_from_mt_entry+0x4c><== ALWAYS TAKEN
 2004c20:	01 00 00 00 	nop                                            
    rtems_filesystem_do_unmount(loc->mt_entry);                       
 2004c24:	f0 06 20 14 	ld  [ %i0 + 0x14 ], %i0                        <== NOT EXECUTED
 2004c28:	7f ff ff d0 	call  2004b68 <rtems_filesystem_do_unmount>    <== NOT EXECUTED
 2004c2c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 2004c30:	81 c7 e0 08 	ret                                            
 2004c34:	81 e8 00 00 	restore                                        
                                                                      

02004e18 <rtems_filesystem_location_transform_to_global>: } rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global( rtems_filesystem_location_info_t *loc ) {
 2004e18:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
 2004e1c:	7f ff fa b9 	call  2003900 <malloc>                         
 2004e20:	90 10 20 24 	mov  0x24, %o0                                 
                                                                      
  if (global_loc != NULL) {                                           
 2004e24:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2004e28:	02 80 00 0b 	be  2004e54 <rtems_filesystem_location_transform_to_global+0x3c><== NEVER TAKEN
 2004e2c:	82 10 20 01 	mov  1, %g1                                    
    global_loc->reference_count = 1;                                  
    global_loc->deferred_released_next = NULL;                        
 2004e30:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            
)                                                                     
{                                                                     
  rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
                                                                      
  if (global_loc != NULL) {                                           
    global_loc->reference_count = 1;                                  
 2004e34:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
    global_loc->deferred_released_next = NULL;                        
    global_loc->deferred_released_count = 0;                          
 2004e38:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
    rtems_filesystem_location_copy(&global_loc->location, loc);       
 2004e3c:	7f ff ff 2f 	call  2004af8 <rtems_filesystem_location_copy> 
 2004e40:	92 10 00 18 	mov  %i0, %o1                                  
    rtems_filesystem_location_remove_from_mt_entry(loc);              
 2004e44:	7f ff ff 68 	call  2004be4 <rtems_filesystem_location_remove_from_mt_entry>
 2004e48:	90 10 00 18 	mov  %i0, %o0                                  
    global_loc = rtems_filesystem_global_location_obtain_null();      
    errno = ENOMEM;                                                   
  }                                                                   
                                                                      
  return global_loc;                                                  
}                                                                     
 2004e4c:	81 c7 e0 08 	ret                                            
 2004e50:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    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);                              
 2004e54:	40 00 1b f7 	call  200be30 <rtems_filesystem_location_free> <== NOT EXECUTED
 2004e58:	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 );      
 2004e5c:	90 07 bf fc 	add  %fp, -4, %o0                              <== NOT EXECUTED
 2004e60:	7f ff ff bc 	call  2004d50 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
 2004e64:	c0 27 bf fc 	clr  [ %fp + -4 ]                              <== NOT EXECUTED
    global_loc = rtems_filesystem_global_location_obtain_null();      
    errno = ENOMEM;                                                   
 2004e68:	40 00 2a 01 	call  200f66c <__errno>                        <== NOT EXECUTED
 2004e6c:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
 2004e70:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
 2004e74:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return global_loc;                                                  
}                                                                     
 2004e78:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 2004e7c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004e80:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02003d94 <rtems_gxx_key_create>: int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) {
 2003d94:	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 ) );
 2003d98:	40 00 01 05 	call  20041ac <malloc>                         
 2003d9c:	90 10 20 08 	mov  8, %o0                                    
  *key = new_key;                                                     
 2003da0:	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 ) );
 2003da4:	ba 10 00 08 	mov  %o0, %i5                                  
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
 2003da8:	c0 22 00 00 	clr  [ %o0 ]                                   
  new_key->dtor = dtor;                                               
 2003dac:	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 );
 2003db0:	92 10 00 1d 	mov  %i5, %o1                                  
 2003db4:	90 10 20 00 	clr  %o0                                       
 2003db8:	94 10 00 19 	mov  %i1, %o2                                  
 2003dbc:	40 00 11 ff 	call  20085b8 <rtems_task_variable_add>        
 2003dc0:	b0 10 20 00 	clr  %i0                                       
  if ( status == RTEMS_SUCCESSFUL )                                   
 2003dc4:	80 a2 20 00 	cmp  %o0, 0                                    
 2003dc8:	02 80 00 04 	be  2003dd8 <rtems_gxx_key_create+0x44>        <== ALWAYS TAKEN
 2003dcc:	90 10 00 1d 	mov  %i5, %o0                                  
    return 0;                                                         
                                                                      
  free( new_key );                                                    
 2003dd0:	7f ff ff 85 	call  2003be4 <free>                           <== NOT EXECUTED
 2003dd4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  return -1;                                                          
}                                                                     
 2003dd8:	81 c7 e0 08 	ret                                            
 2003ddc:	81 e8 00 00 	restore                                        
                                                                      

02003dec <rtems_gxx_key_delete>: int rtems_gxx_key_delete (__gthread_key_t key) {
 2003dec:	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 );    
 2003df0:	90 10 20 00 	clr  %o0                                       
 2003df4:	40 00 12 1c 	call  2008664 <rtems_task_variable_delete>     
 2003df8:	92 10 00 18 	mov  %i0, %o1                                  
  if ( status == RTEMS_SUCCESSFUL ) {                                 
 2003dfc:	80 a2 20 00 	cmp  %o0, 0                                    
 2003e00:	12 80 00 06 	bne  2003e18 <rtems_gxx_key_delete+0x2c>       <== NEVER TAKEN
 2003e04:	80 a6 20 00 	cmp  %i0, 0                                    
    /* Hmm - hopefully all tasks using this key have gone away... */  
    if ( key ) free( *(void **)key );                                 
 2003e08:	02 80 00 04 	be  2003e18 <rtems_gxx_key_delete+0x2c>        <== NEVER TAKEN
 2003e0c:	01 00 00 00 	nop                                            
 2003e10:	7f ff ff 75 	call  2003be4 <free>                           
 2003e14:	d0 06 00 00 	ld  [ %i0 ], %o0                               
    return 0;                                                         
  }                                                                   
  key = NULL;                                                         
  return 0;                                                           
}                                                                     
 2003e18:	81 c7 e0 08 	ret                                            
 2003e1c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02003d30 <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)) {
 2003d30:	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 ) {                    
 2003d34:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 2003d38:	80 a0 60 00 	cmp  %g1, 0                                    
 2003d3c:	12 80 00 14 	bne  2003d8c <rtems_gxx_once+0x5c>             
 2003d40:	90 10 21 00 	mov  0x100, %o0                                
    rtems_mode saveMode;                                              
    __gthread_once_t o;                                               
                                                                      
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
 2003d44:	92 10 21 00 	mov  0x100, %o1                                
 2003d48:	40 00 11 a2 	call  20083d0 <rtems_task_mode>                
 2003d4c:	94 07 bf fc 	add  %fp, -4, %o2                              
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
 2003d50:	fa 06 00 00 	ld  [ %i0 ], %i5                               
 2003d54:	80 a7 60 00 	cmp  %i5, 0                                    
 2003d58:	12 80 00 05 	bne  2003d6c <rtems_gxx_once+0x3c>             <== NEVER TAKEN
 2003d5c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      *(volatile __gthread_once_t *)once = 1;                         
 2003d60:	82 10 20 01 	mov  1, %g1                                    
 2003d64:	c2 26 00 00 	st  %g1, [ %i0 ]                               
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
 2003d68:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
 2003d6c:	92 10 21 00 	mov  0x100, %o1                                
 2003d70:	40 00 11 98 	call  20083d0 <rtems_task_mode>                
 2003d74:	94 07 bf fc 	add  %fp, -4, %o2                              
    if ( o == 0 )                                                     
 2003d78:	80 a7 60 00 	cmp  %i5, 0                                    
 2003d7c:	12 80 00 04 	bne  2003d8c <rtems_gxx_once+0x5c>             <== NEVER TAKEN
 2003d80:	01 00 00 00 	nop                                            
      (*func)();                                                      
 2003d84:	9f c6 40 00 	call  %i1                                      
 2003d88:	01 00 00 00 	nop                                            
  }                                                                   
  return 0;                                                           
}                                                                     
 2003d8c:	81 c7 e0 08 	ret                                            
 2003d90:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02003e84 <rtems_gxx_setspecific>: int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) {
 2003e84:	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 );
 2003e88:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
 2003e8c:	90 10 20 00 	clr  %o0                                       
 2003e90:	40 00 11 ca 	call  20085b8 <rtems_task_variable_add>        
 2003e94:	92 10 00 18 	mov  %i0, %o1                                  
  if ( status == RTEMS_SUCCESSFUL ) {                                 
 2003e98:	80 a2 20 00 	cmp  %o0, 0                                    
 2003e9c:	12 80 00 05 	bne  2003eb0 <rtems_gxx_setspecific+0x2c>      <== NEVER TAKEN
 2003ea0:	01 00 00 00 	nop                                            
    /* now let's set the proper value */                              
    key->val =  (void *)ptr;                                          
 2003ea4:	f2 26 00 00 	st  %i1, [ %i0 ]                               
    return 0;                                                         
 2003ea8:	81 c7 e0 08 	ret                                            
 2003eac:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
  return -1;                                                          
}                                                                     
 2003eb0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2003eb4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

02007ca8 <rtems_heap_allocate_aligned_with_boundary>: void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) {
 2007ca8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (                                                                
 2007cac:	03 00 80 92 	sethi  %hi(0x2024800), %g1                     
 2007cb0:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1	! 2024898 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(                      
  size_t size,                                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
 2007cb4:	ba 10 00 18 	mov  %i0, %i5                                  
 2007cb8:	b8 10 00 19 	mov  %i1, %i4                                  
  if (                                                                
 2007cbc:	80 a0 60 03 	cmp  %g1, 3                                    
 2007cc0:	02 80 00 08 	be  2007ce0 <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
 2007cc4:	b6 10 00 1a 	mov  %i2, %i3                                  
      && !malloc_is_system_state_OK()                                 
  ) {                                                                 
    return NULL;                                                      
  }                                                                   
                                                                      
  malloc_deferred_frees_process();                                    
 2007cc8:	7f ff fb ef 	call  2006c84 <malloc_deferred_frees_process>  
 2007ccc:	b2 10 00 1d 	mov  %i5, %i1                                  
                                                                      
  /* FIXME: Statistics, boundary checks */                            
                                                                      
  return _Protected_heap_Allocate_aligned_with_boundary(              
 2007cd0:	03 00 80 8b 	sethi  %hi(0x2022c00), %g1                     
 2007cd4:	f0 00 62 84 	ld  [ %g1 + 0x284 ], %i0	! 2022e84 <RTEMS_Malloc_Heap>
 2007cd8:	40 00 17 b9 	call  200dbbc <_Protected_heap_Allocate_aligned_with_boundary>
 2007cdc:	95 e8 00 1c 	restore  %g0, %i4, %o2                         
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
  if (                                                                
    _System_state_Is_up( _System_state_Get() )                        
      && !malloc_is_system_state_OK()                                 
 2007ce0:	7f ff fb dd 	call  2006c54 <malloc_is_system_state_OK>      
 2007ce4:	01 00 00 00 	nop                                            
 2007ce8:	80 8a 20 ff 	btst  0xff, %o0                                
 2007cec:	12 bf ff f7 	bne  2007cc8 <rtems_heap_allocate_aligned_with_boundary+0x20>
 2007cf0:	b0 10 20 00 	clr  %i0                                       
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment,                                                        
    boundary                                                          
  );                                                                  
}                                                                     
 2007cf4:	81 c7 e0 08 	ret                                            
 2007cf8:	81 e8 00 00 	restore                                        
                                                                      

020044f0 <rtems_heap_extend_via_sbrk>: void *rtems_heap_extend_via_sbrk( Heap_Control *heap, size_t alloc_size ) {
 20044f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;                   
 20044f4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20044f8:	f8 00 63 40 	ld  [ %g1 + 0x340 ], %i4	! 201d740 <RTEMS_Malloc_Sbrk_amount>
  ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;                       
  ptrdiff_t misaligned = sbrk_size % sbrk_amount;                     
 20044fc:	90 10 00 19 	mov  %i1, %o0                                  
 2004500:	92 10 00 1c 	mov  %i4, %o1                                  
 2004504:	40 00 51 41 	call  2018a08 <.rem>                           
 2004508:	ba 10 00 19 	mov  %i1, %i5                                  
  void *return_this = NULL;                                           
                                                                      
  if ( misaligned != 0 ) {                                            
 200450c:	80 a2 20 00 	cmp  %o0, 0                                    
 2004510:	02 80 00 05 	be  2004524 <rtems_heap_extend_via_sbrk+0x34>  
 2004514:	80 a7 60 00 	cmp  %i5, 0                                    
    sbrk_size += sbrk_amount - misaligned;                            
 2004518:	ba 27 00 08 	sub  %i4, %o0, %i5                             
 200451c:	ba 06 40 1d 	add  %i1, %i5, %i5                             
  }                                                                   
                                                                      
  if ( sbrk_size > 0 && sbrk_amount > 0 ) {                           
 2004520:	80 a7 60 00 	cmp  %i5, 0                                    
 2004524:	04 80 00 17 	ble  2004580 <rtems_heap_extend_via_sbrk+0x90> <== NEVER TAKEN
 2004528:	80 a7 20 00 	cmp  %i4, 0                                    
 200452c:	04 80 00 15 	ble  2004580 <rtems_heap_extend_via_sbrk+0x90> <== NEVER TAKEN
 2004530:	01 00 00 00 	nop                                            
    void *area_begin = sbrk( sbrk_size );                             
 2004534:	7f ff f3 e8 	call  20014d4 <sbrk>                           
 2004538:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if ( area_begin != (void *) -1 ) {                                
 200453c:	80 a2 3f ff 	cmp  %o0, -1                                   
 2004540:	02 80 00 10 	be  2004580 <rtems_heap_extend_via_sbrk+0x90>  
 2004544:	92 10 00 08 	mov  %o0, %o1                                  
      bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
 2004548:	90 10 00 18 	mov  %i0, %o0                                  
 200454c:	40 00 13 74 	call  200931c <_Protected_heap_Extend>         
 2004550:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
      if ( ok ) {                                                     
 2004554:	80 8a 20 ff 	btst  0xff, %o0                                
 2004558:	02 80 00 08 	be  2004578 <rtems_heap_extend_via_sbrk+0x88>  
 200455c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
        MSBUMP( space_available, sbrk_size );                         
 2004560:	c4 00 63 10 	ld  [ %g1 + 0x310 ], %g2	! 201d710 <rtems_malloc_statistics>
 2004564:	b4 10 20 00 	clr  %i2                                       
 2004568:	ba 07 40 02 	add  %i5, %g2, %i5                             
 200456c:	fa 20 63 10 	st  %i5, [ %g1 + 0x310 ]                       
 2004570:	40 00 13 5d 	call  20092e4 <_Protected_heap_Allocate_aligned_with_boundary>
 2004574:	97 e8 20 00 	restore  %g0, 0, %o3                           
                                                                      
        return_this = _Protected_heap_Allocate( heap, alloc_size );   
      } else {                                                        
        sbrk( -sbrk_size );                                           
 2004578:	7f ff f3 d7 	call  20014d4 <sbrk>                           
 200457c:	90 20 00 1d 	neg  %i5, %o0                                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return return_this;                                                 
}                                                                     
 2004580:	81 c7 e0 08 	ret                                            
 2004584:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

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

02004d40 <rtems_ide_part_table_free>: * N/A */ void rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc) { partition_table_free( disk_desc );
 2004d40:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 2004d44:	7f ff fe d1 	call  2004888 <partition_table_free>           <== NOT EXECUTED
 2004d48:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

02004d4c <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 );
 2004d4c:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 2004d50:	7f ff ff 87 	call  2004b6c <partition_table_get>            <== NOT EXECUTED
 2004d54:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

02004d58 <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) {
 2004d58:	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));
 2004d5c:	90 10 20 01 	mov  1, %o0                                    
 2004d60:	92 10 21 28 	mov  0x128, %o1                                
 2004d64:	40 00 01 f5 	call  2005538 <calloc>                         
 2004d68:	b6 10 20 1a 	mov  0x1a, %i3                                 
    if (disk_desc == NULL)                                            
 2004d6c:	80 a2 20 00 	cmp  %o0, 0                                    
 2004d70:	02 80 00 34 	be  2004e40 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
 2004d74:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    /* get partition table */                                         
    rc = partition_table_get(dev_name, disk_desc);                    
 2004d78:	90 10 00 18 	mov  %i0, %o0                                  
 2004d7c:	7f ff ff 7c 	call  2004b6c <partition_table_get>            
 2004d80:	92 10 00 1d 	mov  %i5, %o1                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
 2004d84:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2004d88:	02 80 00 06 	be  2004da0 <rtems_ide_part_table_initialize+0x48><== ALWAYS TAKEN
 2004d8c:	23 00 80 90 	sethi  %hi(0x2024000), %l1                     
    {                                                                 
        free(disk_desc);                                              
 2004d90:	40 00 02 be 	call  2005888 <free>                           <== NOT EXECUTED
 2004d94:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    partition_table_free(disk_desc);                                  
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
 2004d98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004d9c:	91 e8 00 1b 	restore  %g0, %i3, %o0                         <== NOT EXECUTED
                                                                      
        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);
 2004da0:	27 00 80 90 	sethi  %hi(0x2024000), %l3                     
    /* 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);      
 2004da4:	f2 07 40 00 	ld  [ %i5 ], %i1                               
 2004da8:	e0 07 60 04 	ld  [ %i5 + 4 ], %l0                           
                                                                      
    /* create logical disks on the physical one */                    
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
 2004dac:	b8 10 20 00 	clr  %i4                                       
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
 2004db0:	b4 07 bf f0 	add  %fp, -16, %i2                             
 2004db4:	a2 14 63 08 	or  %l1, 0x308, %l1                            
                                                                      
        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);
 2004db8:	25 00 80 98 	sethi  %hi(0x2026000), %l2                     
     */                                                               
                                                                      
    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++) 
 2004dbc:	10 80 00 1b 	b  2004e28 <rtems_ide_part_table_initialize+0xd0>
 2004dc0:	a6 14 e3 10 	or  %l3, 0x310, %l3                            
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
 2004dc4:	92 10 00 11 	mov  %l1, %o1                                  
 2004dc8:	90 10 00 1a 	mov  %i2, %o0                                  
 2004dcc:	94 10 00 18 	mov  %i0, %o2                                  
 2004dd0:	40 00 43 f6 	call  2015da8 <sprintf>                        
 2004dd4:	96 10 00 1c 	mov  %i4, %o3                                  
 *      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)                 
 2004dd8:	83 2f 20 02 	sll  %i4, 2, %g1                               
 2004ddc:	82 07 40 01 	add  %i5, %g1, %g1                             
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++) 
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
        dev = rtems_filesystem_make_dev_t(major, ++minor);            
                                                                      
        part_desc = disk_desc->partitions[part_num];                  
 2004de0:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
        if (part_desc == NULL)                                        
 2004de4:	80 a0 60 00 	cmp  %g1, 0                                    
 2004de8:	02 80 00 10 	be  2004e28 <rtems_ide_part_table_initialize+0xd0>
 2004dec:	92 07 00 10 	add  %i4, %l0, %o1                             
        {                                                             
            continue;                                                 
        }                                                             
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
 2004df0:	d4 1f 40 00 	ldd  [ %i5 ], %o2                              
 2004df4:	d8 00 60 04 	ld  [ %g1 + 4 ], %o4                           
 2004df8:	da 00 60 08 	ld  [ %g1 + 8 ], %o5                           
 2004dfc:	90 10 00 19 	mov  %i1, %o0                                  
 2004e00:	7f ff fd 63 	call  200438c <rtems_disk_create_log>          
 2004e04:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
                                   part_desc->size, name);            
        if (rc != RTEMS_SUCCESSFUL)                                   
 2004e08:	96 92 20 00 	orcc  %o0, 0, %o3                              
 2004e0c:	22 80 00 08 	be,a   2004e2c <rtems_ide_part_table_initialize+0xd4><== ALWAYS TAKEN
 2004e10:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
        {                                                             
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
 2004e14:	c2 04 a2 c8 	ld  [ %l2 + 0x2c8 ], %g1                       <== NOT EXECUTED
 2004e18:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
 2004e1c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
 2004e20:	40 00 41 54 	call  2015370 <fprintf>                        <== NOT EXECUTED
 2004e24:	94 10 00 1a 	mov  %i2, %o2                                  <== 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++) 
 2004e28:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 2004e2c:	80 a7 00 01 	cmp  %i4, %g1                                  
 2004e30:	26 bf ff e5 	bl,a   2004dc4 <rtems_ide_part_table_initialize+0x6c>
 2004e34:	b8 07 20 01 	inc  %i4                                       
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
            continue;                                                 
        }                                                             
    }                                                                 
                                                                      
    partition_table_free(disk_desc);                                  
 2004e38:	7f ff fe 94 	call  2004888 <partition_table_free>           
 2004e3c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
 2004e40:	b0 10 00 1b 	mov  %i3, %i0                                  
 2004e44:	81 c7 e0 08 	ret                                            
 2004e48:	81 e8 00 00 	restore                                        
                                                                      

0200a3b8 <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) {
 200a3b8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
 200a3bc:	ba 10 20 01 	mov  1, %i5                                    
 200a3c0:	80 a6 20 00 	cmp  %i0, 0                                    
 200a3c4:	02 80 00 0d 	be  200a3f8 <rtems_iterate_over_all_threads+0x40><== NEVER TAKEN
 200a3c8:	35 00 80 80 	sethi  %hi(0x2020000), %i2                     
#endif                                                                
                                                                      
#include <rtems/system.h>                                             
#include <rtems/score/thread.h>                                       
                                                                      
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) 
 200a3cc:	83 2f 60 02 	sll  %i5, 2, %g1                               
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
 200a3d0:	84 16 a1 74 	or  %i2, 0x174, %g2                            
 200a3d4:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 200a3d8:	f6 00 60 04 	ld  [ %g1 + 4 ], %i3                           
    if ( !information )                                               
 200a3dc:	80 a6 e0 00 	cmp  %i3, 0                                    
 200a3e0:	12 80 00 0f 	bne  200a41c <rtems_iterate_over_all_threads+0x64>
 200a3e4:	b8 10 20 01 	mov  1, %i4                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
 200a3e8:	ba 07 60 01 	inc  %i5                                       
 200a3ec:	80 a7 60 04 	cmp  %i5, 4                                    
 200a3f0:	12 bf ff f8 	bne  200a3d0 <rtems_iterate_over_all_threads+0x18>
 200a3f4:	83 2f 60 02 	sll  %i5, 2, %g1                               
 200a3f8:	81 c7 e0 08 	ret                                            
 200a3fc:	81 e8 00 00 	restore                                        
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
      the_thread = (Thread_Control *)information->local_table[ i ];   
 200a400:	83 2f 20 02 	sll  %i4, 2, %g1                               
 200a404:	d0 00 80 01 	ld  [ %g2 + %g1 ], %o0                         
                                                                      
      if ( !the_thread )                                              
 200a408:	80 a2 20 00 	cmp  %o0, 0                                    
 200a40c:	02 80 00 04 	be  200a41c <rtems_iterate_over_all_threads+0x64>
 200a410:	b8 07 20 01 	inc  %i4                                       
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
 200a414:	9f c6 00 00 	call  %i0                                      
 200a418:	01 00 00 00 	nop                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
    if ( !information )                                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
 200a41c:	c2 16 e0 10 	lduh  [ %i3 + 0x10 ], %g1                      
 200a420:	80 a7 00 01 	cmp  %i4, %g1                                  
 200a424:	28 bf ff f7 	bleu,a   200a400 <rtems_iterate_over_all_threads+0x48>
 200a428:	c4 06 e0 1c 	ld  [ %i3 + 0x1c ], %g2                        
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
    return;                                                           
                                                                      
  for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
 200a42c:	10 bf ff f0 	b  200a3ec <rtems_iterate_over_all_threads+0x34>
 200a430:	ba 07 60 01 	inc  %i5                                       
                                                                      

020036fc <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 ) {
 20036fc:	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)                                  
 2003700:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2003704:	fa 00 61 f4 	ld  [ %g1 + 0x1f4 ], %i5	! 201c9f4 <rtems_libio_number_iops>
 2003708:	80 a7 60 00 	cmp  %i5, 0                                    
 200370c:	02 80 00 1b 	be  2003778 <rtems_libio_init+0x7c>            <== NEVER TAKEN
 2003710:	11 13 10 92 	sethi  %hi(0x4c424800), %o0                    
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
 2003714:	90 10 00 1d 	mov  %i5, %o0                                  
 2003718:	7f ff fe f3 	call  20032e4 <calloc>                         
 200371c:	92 10 20 38 	mov  0x38, %o1                                 
 2003720:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
 2003724:	80 a2 20 00 	cmp  %o0, 0                                    
 2003728:	12 80 00 04 	bne  2003738 <rtems_libio_init+0x3c>           
 200372c:	d0 20 60 44 	st  %o0, [ %g1 + 0x44 ]                        
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
 2003730:	10 80 00 1c 	b  20037a0 <rtems_libio_init+0xa4>             
 2003734:	90 10 20 1a 	mov  0x1a, %o0                                 
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
 2003738:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
 200373c:	84 10 00 08 	mov  %o0, %g2                                  
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
 2003740:	d0 20 60 48 	st  %o0, [ %g1 + 0x48 ]                        
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
 2003744:	10 80 00 03 	b  2003750 <rtems_libio_init+0x54>             
 2003748:	82 10 20 00 	clr  %g1                                       
          iop->data1 = iop + 1;                                       
 200374c:	c4 20 bf f8 	st  %g2, [ %g2 + -8 ]                          
                                                    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++)  
 2003750:	82 00 60 01 	inc  %g1                                       
 2003754:	80 a0 40 1d 	cmp  %g1, %i5                                  
 2003758:	12 bf ff fd 	bne  200374c <rtems_libio_init+0x50>           
 200375c:	84 00 a0 38 	add  %g2, 0x38, %g2                            
          iop->data1 = iop + 1;                                       
        iop->data1 = NULL;                                            
 2003760:	85 28 60 03 	sll  %g1, 3, %g2                               
 2003764:	83 28 60 06 	sll  %g1, 6, %g1                               
 2003768:	82 20 40 02 	sub  %g1, %g2, %g1                             
 200376c:	90 02 00 01 	add  %o0, %g1, %o0                             
 2003770:	c0 22 3f f8 	clr  [ %o0 + -8 ]                              
  /*                                                                  
   *  Create the binary semaphore used to provide mutual exclusion    
   *  on the IOP Table.                                               
   */                                                                 
                                                                      
  rc = rtems_semaphore_create(                                        
 2003774:	11 13 10 92 	sethi  %hi(0x4c424800), %o0                    
 2003778:	92 10 20 01 	mov  1, %o1                                    
 200377c:	90 12 21 4f 	or  %o0, 0x14f, %o0                            
 2003780:	94 10 20 54 	mov  0x54, %o2                                 
 2003784:	96 10 20 00 	clr  %o3                                       
 2003788:	19 00 80 75 	sethi  %hi(0x201d400), %o4                     
 200378c:	40 00 0f 31 	call  2007450 <rtems_semaphore_create>         
 2003790:	98 13 20 4c 	or  %o4, 0x4c, %o4	! 201d44c <rtems_libio_semaphore>
    1,                                                                
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
 2003794:	80 a2 20 00 	cmp  %o0, 0                                    
 2003798:	02 80 00 04 	be  20037a8 <rtems_libio_init+0xac>            <== ALWAYS TAKEN
 200379c:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
    rtems_fatal_error_occurred( rc );                                 
 20037a0:	40 00 11 a6 	call  2007e38 <rtems_fatal_error_occurred>     
 20037a4:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  if (rtems_fs_init_helper)                                           
 20037a8:	c2 00 61 f8 	ld  [ %g1 + 0x1f8 ], %g1                       
 20037ac:	80 a0 60 00 	cmp  %g1, 0                                    
 20037b0:	02 80 00 04 	be  20037c0 <rtems_libio_init+0xc4>            
 20037b4:	01 00 00 00 	nop                                            
     (* rtems_fs_init_helper)();                                      
 20037b8:	9f c0 40 00 	call  %g1                                      
 20037bc:	01 00 00 00 	nop                                            
 20037c0:	81 c7 e0 08 	ret                                            
 20037c4:	81 e8 00 00 	restore                                        
                                                                      

02004678 <rtems_libio_set_private_env>: } rtems_status_code rtems_libio_set_private_env(void) {
 2004678:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
 200467c:	40 00 05 d9 	call  2005de0 <rtems_task_self>                
 2004680:	01 00 00 00 	nop                                            
  rtems_user_env_t *old_env = rtems_current_user_env;                 
 2004684:	03 00 80 48 	sethi  %hi(0x2012000), %g1                     
 2004688:	f8 00 61 dc 	ld  [ %g1 + 0x1dc ], %i4	! 20121dc <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;            
 200468c:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
                                                                      
  if (uses_global_env || uses_shared_env) {                           
 2004690:	80 a0 40 08 	cmp  %g1, %o0                                  
 2004694:	12 80 00 07 	bne  20046b0 <rtems_libio_set_private_env+0x38>
 2004698:	b6 10 00 08 	mov  %o0, %i3                                  
 200469c:	03 00 80 48 	sethi  %hi(0x2012000), %g1                     
 20046a0:	82 10 61 e0 	or  %g1, 0x1e0, %g1	! 20121e0 <rtems_global_user_env>
 20046a4:	80 a7 00 01 	cmp  %i4, %g1                                  
 20046a8:	12 80 00 2b 	bne  2004754 <rtems_libio_set_private_env+0xdc><== ALWAYS TAKEN
 20046ac:	b0 10 20 00 	clr  %i0                                       
    rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));          
 20046b0:	90 10 20 01 	mov  1, %o0                                    
 20046b4:	92 10 20 2c 	mov  0x2c, %o1                                 
 20046b8:	40 00 13 7e 	call  20094b0 <calloc>                         
 20046bc:	b0 10 20 1a 	mov  0x1a, %i0                                 
                                                                      
    if (new_env != NULL) {                                            
 20046c0:	80 a2 20 00 	cmp  %o0, 0                                    
 20046c4:	02 80 00 24 	be  2004754 <rtems_libio_set_private_env+0xdc> 
 20046c8:	ba 10 00 08 	mov  %o0, %i5                                  
      *new_env = *old_env;                                            
 20046cc:	92 10 00 1c 	mov  %i4, %o1                                  
 20046d0:	40 00 1f 0a 	call  200c2f8 <memcpy>                         
 20046d4:	94 10 20 2c 	mov  0x2c, %o2                                 
      new_env->reference_count = 1;                                   
 20046d8:	82 10 20 01 	mov  1, %g1                                    
      new_env->task_id = self_task_id;                                
 20046dc:	f6 27 60 24 	st  %i3, [ %i5 + 0x24 ]                        
  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;                                   
 20046e0:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
      new_env->task_id = self_task_id;                                
      new_env->root_directory =                                       
        rtems_filesystem_global_location_obtain(&old_env->root_directory);
 20046e4:	40 00 02 d4 	call  2005234 <rtems_filesystem_global_location_obtain>
 20046e8:	90 07 20 04 	add  %i4, 4, %o0                               
                                                                      
    if (new_env != NULL) {                                            
      *new_env = *old_env;                                            
      new_env->reference_count = 1;                                   
      new_env->task_id = self_task_id;                                
      new_env->root_directory =                                       
 20046ec:	d0 27 60 04 	st  %o0, [ %i5 + 4 ]                           
        rtems_filesystem_global_location_obtain(&old_env->root_directory);
      new_env->current_directory =                                    
        rtems_filesystem_global_location_obtain(&old_env->current_directory);
 20046f0:	40 00 02 d1 	call  2005234 <rtems_filesystem_global_location_obtain>
 20046f4:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
static inline bool rtems_filesystem_location_is_null(                 
  const rtems_filesystem_location_info_t *loc                         
)                                                                     
{                                                                     
  return loc->handlers == &rtems_filesystem_null_handlers;            
 20046f8:	c2 07 60 04 	ld  [ %i5 + 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 =                                    
 20046fc:	d0 27 40 00 	st  %o0, [ %i5 ]                               
        rtems_filesystem_global_location_obtain(&old_env->current_directory);
                                                                      
      if (                                                            
 2004700:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 2004704:	03 00 80 46 	sethi  %hi(0x2011800), %g1                     
 2004708:	82 10 62 b4 	or  %g1, 0x2b4, %g1	! 2011ab4 <rtems_filesystem_null_handlers>
 200470c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2004710:	22 80 00 14 	be,a   2004760 <rtems_libio_set_private_env+0xe8>
 2004714:	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)
 2004718:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
 200471c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2004720:	02 80 00 0f 	be  200475c <rtems_libio_set_private_env+0xe4> <== NEVER TAKEN
 2004724:	90 10 20 00 	clr  %o0                                       
      ) {                                                             
        sc = rtems_task_variable_add(                                 
 2004728:	37 00 80 48 	sethi  %hi(0x2012000), %i3                     
 200472c:	15 00 80 11 	sethi  %hi(0x2004400), %o2                     
 2004730:	92 16 e1 dc 	or  %i3, 0x1dc, %o1                            
 2004734:	40 00 05 cb 	call  2005e60 <rtems_task_variable_add>        
 2004738:	94 12 a2 08 	or  %o2, 0x208, %o2                            
          RTEMS_SELF,                                                 
          (void **) &rtems_current_user_env,                          
          free_user_env                                               
        );                                                            
        if (sc == RTEMS_SUCCESSFUL) {                                 
 200473c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2004740:	32 80 00 08 	bne,a   2004760 <rtems_libio_set_private_env+0xe8>
 2004744:	b0 10 20 05 	mov  5, %i0                                    
          free_user_env_protected(old_env);                           
 2004748:	7f ff ff c3 	call  2004654 <free_user_env_protected>        
 200474c:	90 10 00 1c 	mov  %i4, %o0                                  
          rtems_current_user_env = new_env;                           
 2004750:	fa 26 e1 dc 	st  %i5, [ %i3 + 0x1dc ]                       
 2004754:	81 c7 e0 08 	ret                                            
 2004758:	81 e8 00 00 	restore                                        
 200475c:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
      } else {                                                        
        sc = RTEMS_UNSATISFIED;                                       
      }                                                               
                                                                      
      if (sc != RTEMS_SUCCESSFUL) {                                   
        free_user_env(new_env);                                       
 2004760:	7f ff ff aa 	call  2004608 <free_user_env>                  
 2004764:	90 10 00 1d 	mov  %i5, %o0                                  
      sc = RTEMS_NO_MEMORY;                                           
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 2004768:	81 c7 e0 08 	ret                                            
 200476c:	81 e8 00 00 	restore                                        
                                                                      

02004770 <rtems_libio_share_private_env>: rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
 2004770:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
 2004774:	40 00 05 9b 	call  2005de0 <rtems_task_self>                
 2004778:	01 00 00 00 	nop                                            
                                                                      
  if (task_id != RTEMS_SELF && self_task_id != task_id) {             
 200477c:	80 a2 00 18 	cmp  %o0, %i0                                  
 2004780:	22 80 00 26 	be,a   2004818 <rtems_libio_share_private_env+0xa8>
 2004784:	b0 10 20 00 	clr  %i0                                       
 2004788:	80 a6 20 00 	cmp  %i0, 0                                    
 200478c:	22 80 00 23 	be,a   2004818 <rtems_libio_share_private_env+0xa8>
 2004790:	b0 10 20 00 	clr  %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;                  
 2004794:	03 00 80 4a 	sethi  %hi(0x2012800), %g1                     
 2004798:	c4 00 63 30 	ld  [ %g1 + 0x330 ], %g2	! 2012b30 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 200479c:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 20047a0:	c4 20 63 30 	st  %g2, [ %g1 + 0x330 ]                       
    /*                                                                
     * We have to disable the thread dispatching to prevent deletion of the
     * environment in the meantime.                                   
     */                                                               
    _Thread_Disable_dispatch();                                       
    sc = rtems_task_variable_get(                                     
 20047a4:	13 00 80 48 	sethi  %hi(0x2012000), %o1                     
 20047a8:	90 10 00 18 	mov  %i0, %o0                                  
 20047ac:	92 12 61 dc 	or  %o1, 0x1dc, %o1                            
 20047b0:	40 00 05 fc 	call  2005fa0 <rtems_task_variable_get>        
 20047b4:	94 07 bf fc 	add  %fp, -4, %o2                              
      task_id,                                                        
      (void *) &rtems_current_user_env,                               
      (void *) &env                                                   
    );                                                                
    if (sc == RTEMS_SUCCESSFUL) {                                     
 20047b8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20047bc:	32 80 00 06 	bne,a   20047d4 <rtems_libio_share_private_env+0x64>
 20047c0:	b0 10 20 0d 	mov  0xd, %i0                                  
      ++env->reference_count;                                         
 20047c4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20047c8:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
 20047cc:	84 00 a0 01 	inc  %g2                                       
 20047d0:	c4 20 60 28 	st  %g2, [ %g1 + 0x28 ]                        
    } else {                                                          
      sc = RTEMS_UNSATISFIED;                                         
    }                                                                 
    _Thread_Enable_dispatch();                                        
 20047d4:	40 00 0d fa 	call  2007fbc <_Thread_Enable_dispatch>        
 20047d8:	01 00 00 00 	nop                                            
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
 20047dc:	80 a6 20 00 	cmp  %i0, 0                                    
 20047e0:	12 80 00 0e 	bne  2004818 <rtems_libio_share_private_env+0xa8>
 20047e4:	90 10 20 00 	clr  %o0                                       
      sc = rtems_task_variable_add(                                   
 20047e8:	3b 00 80 48 	sethi  %hi(0x2012000), %i5                     
 20047ec:	15 00 80 11 	sethi  %hi(0x2004400), %o2                     
 20047f0:	92 17 61 dc 	or  %i5, 0x1dc, %o1                            
 20047f4:	40 00 05 9b 	call  2005e60 <rtems_task_variable_add>        
 20047f8:	94 12 a2 08 	or  %o2, 0x208, %o2                            
        RTEMS_SELF,                                                   
        (void **) &rtems_current_user_env,                            
        free_user_env                                                 
      );                                                              
      if (sc == RTEMS_SUCCESSFUL) {                                   
 20047fc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2004800:	12 80 00 08 	bne  2004820 <rtems_libio_share_private_env+0xb0><== NEVER TAKEN
 2004804:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
        free_user_env_protected(rtems_current_user_env);              
 2004808:	7f ff ff 93 	call  2004654 <free_user_env_protected>        
 200480c:	d0 07 61 dc 	ld  [ %i5 + 0x1dc ], %o0                       
        rtems_current_user_env = env;                                 
 2004810:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2004814:	c2 27 61 dc 	st  %g1, [ %i5 + 0x1dc ]                       
 2004818:	81 c7 e0 08 	ret                                            
 200481c:	81 e8 00 00 	restore                                        
      } else {                                                        
        free_user_env_protected(env);                                 
 2004820:	7f ff ff 8d 	call  2004654 <free_user_env_protected>        <== NOT EXECUTED
 2004824:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 2004828:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200482c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200bf60 <rtems_libio_to_fcntl_flags>: int rtems_libio_to_fcntl_flags( uint32_t flags ) { int fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
 200bf60:	84 0a 20 06 	and  %o0, 6, %g2                               
                                                                      
  return flags;                                                       
}                                                                     
                                                                      
int rtems_libio_to_fcntl_flags( uint32_t flags )                      
{                                                                     
 200bf64:	82 10 00 08 	mov  %o0, %g1                                  
  int fcntl_flags = 0;                                                
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
 200bf68:	80 a0 a0 06 	cmp  %g2, 6                                    
 200bf6c:	02 80 00 07 	be  200bf88 <rtems_libio_to_fcntl_flags+0x28>  
 200bf70:	90 10 20 02 	mov  2, %o0                                    
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
 200bf74:	80 88 60 02 	btst  2, %g1                                   
 200bf78:	12 80 00 04 	bne  200bf88 <rtems_libio_to_fcntl_flags+0x28> <== ALWAYS TAKEN
 200bf7c:	90 10 20 00 	clr  %o0                                       
    fcntl_flags |= O_RDONLY;                                          
  } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {     
 200bf80:	91 30 60 02 	srl  %g1, 2, %o0                               <== NOT EXECUTED
 200bf84:	90 0a 20 01 	and  %o0, 1, %o0                               <== NOT EXECUTED
    fcntl_flags |= O_WRONLY;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {     
 200bf88:	80 88 60 01 	btst  1, %g1                                   
 200bf8c:	02 80 00 04 	be  200bf9c <rtems_libio_to_fcntl_flags+0x3c>  
 200bf90:	80 88 62 00 	btst  0x200, %g1                               
    fcntl_flags |= O_NONBLOCK;                                        
 200bf94:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
 200bf98:	90 12 00 02 	or  %o0, %g2, %o0                              
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {         
 200bf9c:	32 80 00 02 	bne,a   200bfa4 <rtems_libio_to_fcntl_flags+0x44>
 200bfa0:	90 12 20 08 	or  %o0, 8, %o0                                
    fcntl_flags |= O_APPEND;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {         
 200bfa4:	80 88 64 00 	btst  0x400, %g1                               
 200bfa8:	32 80 00 02 	bne,a   200bfb0 <rtems_libio_to_fcntl_flags+0x50>
 200bfac:	90 12 22 00 	or  %o0, 0x200, %o0                            
    fcntl_flags |= O_CREAT;                                           
  }                                                                   
                                                                      
  return fcntl_flags;                                                 
}                                                                     
 200bfb0:	81 c3 e0 08 	retl                                           
                                                                      

02004830 <rtems_libio_use_global_env>: return sc; } void rtems_libio_use_global_env(void) {
 2004830:	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) {                                             
 2004834:	3b 00 80 48 	sethi  %hi(0x2012000), %i5                     
 2004838:	c2 07 61 dc 	ld  [ %i5 + 0x1dc ], %g1	! 20121dc <rtems_current_user_env>
 200483c:	39 00 80 48 	sethi  %hi(0x2012000), %i4                     
 2004840:	b8 17 21 e0 	or  %i4, 0x1e0, %i4	! 20121e0 <rtems_global_user_env>
 2004844:	80 a0 40 1c 	cmp  %g1, %i4                                  
 2004848:	02 80 00 0a 	be  2004870 <rtems_libio_use_global_env+0x40>  
 200484c:	92 17 61 dc 	or  %i5, 0x1dc, %o1                            
    sc = rtems_task_variable_delete(                                  
 2004850:	40 00 05 af 	call  2005f0c <rtems_task_variable_delete>     
 2004854:	90 10 20 00 	clr  %o0                                       
      RTEMS_SELF,                                                     
      (void **) &rtems_current_user_env                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
 2004858:	80 a2 20 00 	cmp  %o0, 0                                    
 200485c:	22 80 00 05 	be,a   2004870 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
 2004860:	f8 27 61 dc 	st  %i4, [ %i5 + 0x1dc ]                       
      rtems_fatal_error_occurred(0xdeadbeef);                         
 2004864:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    <== NOT EXECUTED
 2004868:	40 00 06 5d 	call  20061dc <rtems_fatal_error_occurred>     <== NOT EXECUTED
 200486c:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
 2004870:	81 c7 e0 08 	ret                                            
 2004874:	81 e8 00 00 	restore                                        
                                                                      

02006fec <rtems_malloc_statistics_at_free>: * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) {
 2006fec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
 2006ff0:	03 00 80 8b 	sethi  %hi(0x2022c00), %g1                     
 2006ff4:	d0 00 62 84 	ld  [ %g1 + 0x284 ], %o0	! 2022e84 <RTEMS_Malloc_Heap>
 2006ff8:	92 10 00 18 	mov  %i0, %o1                                  
 2006ffc:	40 00 1b 1b 	call  200dc68 <_Protected_heap_Get_block_size> 
 2007000:	94 07 bf fc 	add  %fp, -4, %o2                              
 2007004:	80 8a 20 ff 	btst  0xff, %o0                                
 2007008:	02 80 00 08 	be  2007028 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
 200700c:	03 00 80 90 	sethi  %hi(0x2024000), %g1                     
    MSBUMP(lifetime_freed, size);                                     
 2007010:	c8 07 bf fc 	ld  [ %fp + -4 ], %g4                          
 2007014:	82 10 62 00 	or  %g1, 0x200, %g1                            
 2007018:	c4 18 60 28 	ldd  [ %g1 + 0x28 ], %g2                       
 200701c:	86 80 c0 04 	addcc  %g3, %g4, %g3                           
 2007020:	84 40 a0 00 	addx  %g2, 0, %g2                              
 2007024:	c4 38 60 28 	std  %g2, [ %g1 + 0x28 ]                       
 2007028:	81 c7 e0 08 	ret                                            
 200702c:	81 e8 00 00 	restore                                        
                                                                      

02007030 <rtems_malloc_statistics_at_malloc>: } static void rtems_malloc_statistics_at_malloc( void *pointer ) {
 2007030:	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 )                                                     
 2007034:	80 a6 20 00 	cmp  %i0, 0                                    
 2007038:	02 80 00 14 	be  2007088 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
 200703c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    return;                                                           
                                                                      
  _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
 2007040:	03 00 80 8b 	sethi  %hi(0x2022c00), %g1                     
 2007044:	d0 00 62 84 	ld  [ %g1 + 0x284 ], %o0	! 2022e84 <RTEMS_Malloc_Heap>
 2007048:	92 10 00 18 	mov  %i0, %o1                                  
 200704c:	40 00 1b 07 	call  200dc68 <_Protected_heap_Get_block_size> 
 2007050:	94 07 bf fc 	add  %fp, -4, %o2                              
                                                                      
  MSBUMP(lifetime_allocated, actual_size);                            
 2007054:	03 00 80 90 	sethi  %hi(0x2024000), %g1                     
 2007058:	c8 07 bf fc 	ld  [ %fp + -4 ], %g4                          
 200705c:	82 10 62 00 	or  %g1, 0x200, %g1                            
 2007060:	c4 18 60 20 	ldd  [ %g1 + 0x20 ], %g2                       
 2007064:	86 80 c0 04 	addcc  %g3, %g4, %g3                           
 2007068:	84 40 a0 00 	addx  %g2, 0, %g2                              
 200706c:	c4 38 60 20 	std  %g2, [ %g1 + 0x20 ]                       
                                                                      
  current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
 2007070:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
 2007074:	84 20 c0 02 	sub  %g3, %g2, %g2                             
  if (current_depth > s->max_depth)                                   
 2007078:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
 200707c:	80 a0 80 03 	cmp  %g2, %g3                                  
 2007080:	38 80 00 02 	bgu,a   2007088 <rtems_malloc_statistics_at_malloc+0x58>
 2007084:	c4 20 60 18 	st  %g2, [ %g1 + 0x18 ]                        
 2007088:	81 c7 e0 08 	ret                                            
 200708c:	81 e8 00 00 	restore                                        
                                                                      

020102ac <rtems_memalign>: int rtems_memalign( void **pointer, size_t alignment, size_t size ) {
 20102ac:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *return_this;                                                  
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
 20102b0:	ba 96 20 00 	orcc  %i0, 0, %i5                              
 20102b4:	12 80 00 04 	bne  20102c4 <rtems_memalign+0x18>             
 20102b8:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
    return EINVAL;                                                    
 20102bc:	81 c7 e0 08 	ret                                            
 20102c0:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
  *pointer = NULL;                                                    
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
 20102c4:	c2 00 63 08 	ld  [ %g1 + 0x308 ], %g1                       
 20102c8:	80 a0 60 03 	cmp  %g1, 3                                    
 20102cc:	02 80 00 0f 	be  2010308 <rtems_memalign+0x5c>              
 20102d0:	c0 27 40 00 	clr  [ %i5 ]                                   
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
 20102d4:	7f ff d2 51 	call  2004c18 <malloc_deferred_frees_process>  
 20102d8:	b0 10 20 0c 	mov  0xc, %i0                                  
  Heap_Control *heap,                                                 
  uintptr_t size,                                                     
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return                                                              
 20102dc:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
 20102e0:	d0 00 61 28 	ld  [ %g1 + 0x128 ], %o0	! 2020d28 <RTEMS_Malloc_Heap>
 20102e4:	92 10 00 1a 	mov  %i2, %o1                                  
 20102e8:	94 10 00 19 	mov  %i1, %o2                                  
 20102ec:	7f ff e9 58 	call  200a84c <_Protected_heap_Allocate_aligned_with_boundary>
 20102f0:	96 10 20 00 	clr  %o3                                       
  return_this = _Protected_heap_Allocate_aligned(                     
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment                                                         
  );                                                                  
  if ( !return_this )                                                 
 20102f4:	80 a2 20 00 	cmp  %o0, 0                                    
 20102f8:	12 80 00 0a 	bne  2010320 <rtems_memalign+0x74>             
 20102fc:	b8 10 00 08 	mov  %o0, %i4                                  
 2010300:	81 c7 e0 08 	ret                                            
 2010304:	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() )                                 
 2010308:	7f ff d2 38 	call  2004be8 <malloc_is_system_state_OK>      
 201030c:	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()) &&                    
 2010310:	80 8a 20 ff 	btst  0xff, %o0                                
 2010314:	02 bf ff ea 	be  20102bc <rtems_memalign+0x10>              <== NEVER TAKEN
 2010318:	01 00 00 00 	nop                                            
 201031c:	30 bf ff ee 	b,a   20102d4 <rtems_memalign+0x28>            
    return ENOMEM;                                                    
                                                                      
  /*                                                                  
   *  If configured, update the more involved statistics              
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
 2010320:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 2010324:	c2 00 61 00 	ld  [ %g1 + 0x100 ], %g1	! 2021500 <rtems_malloc_statistics_helpers>
 2010328:	80 a0 60 00 	cmp  %g1, 0                                    
 201032c:	22 80 00 06 	be,a   2010344 <rtems_memalign+0x98>           
 2010330:	f8 27 40 00 	st  %i4, [ %i5 ]                               
    (*rtems_malloc_statistics_helpers->at_malloc)(pointer);           
 2010334:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 2010338:	9f c0 40 00 	call  %g1                                      
 201033c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  *pointer = return_this;                                             
 2010340:	f8 27 40 00 	st  %i4, [ %i5 ]                               
  return 0;                                                           
}                                                                     
 2010344:	81 c7 e0 08 	ret                                            
 2010348:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02009418 <rtems_mkdir>: return (retval); } int rtems_mkdir(const char *path, mode_t mode) {
 2009418:	9d e3 bf 58 	save  %sp, -168, %sp                           
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
 200941c:	40 00 65 ae 	call  2022ad4 <strdup>                         
 2009420:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if (dup_path != NULL) {                                             
 2009424:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2009428:	32 80 00 04 	bne,a   2009438 <rtems_mkdir+0x20>             
 200942c:	c2 4e c0 00 	ldsb  [ %i3 ], %g1                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
 2009430:	81 c7 e0 08 	ret                                            
 2009434:	91 e8 3f ff 	restore  %g0, -1, %o0                          
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
 2009438:	b8 10 20 01 	mov  1, %i4                                    
    ++p;                                                              
 200943c:	82 18 60 2f 	xor  %g1, 0x2f, %g1                            
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
 2009440:	b0 10 20 00 	clr  %i0                                       
    ++p;                                                              
 2009444:	80 a0 00 01 	cmp  %g0, %g1                                  
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
 2009448:	a0 10 20 2f 	mov  0x2f, %l0                                 
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
 200944c:	b4 66 ff ff 	subx  %i3, -1, %i2                             
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
 2009450:	82 10 20 01 	mov  1, %g1                                    
    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)) {                            
 2009454:	23 00 00 3c 	sethi  %hi(0xf000), %l1                        
 2009458:	25 00 00 10 	sethi  %hi(0x4000), %l2                        
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
 200945c:	c6 4e 80 00 	ldsb  [ %i2 ], %g3                             
 2009460:	80 a0 e0 00 	cmp  %g3, 0                                    
 2009464:	22 80 00 07 	be,a   2009480 <rtems_mkdir+0x68>              
 2009468:	84 10 20 01 	mov  1, %g2                                    
      last = 1;                                                       
    else if (p[0] != '/')                                             
 200946c:	80 a0 e0 2f 	cmp  %g3, 0x2f                                 
 2009470:	12 80 00 4f 	bne  20095ac <rtems_mkdir+0x194>               
 2009474:	84 10 20 00 	clr  %g2                                       
      continue;                                                       
    *p = '\0';                                                        
 2009478:	10 80 00 03 	b  2009484 <rtems_mkdir+0x6c>                  
 200947c:	c0 2e 80 00 	clrb  [ %i2 ]                                  
 2009480:	c0 2e 80 00 	clrb  [ %i2 ]                                  
    if (!last && p[1] == '\0')                                        
 2009484:	80 a0 a0 00 	cmp  %g2, 0                                    
 2009488:	12 80 00 05 	bne  200949c <rtems_mkdir+0x84>                
 200948c:	ba 10 20 01 	mov  1, %i5                                    
 2009490:	c4 4e a0 01 	ldsb  [ %i2 + 1 ], %g2                         
 2009494:	80 a0 00 02 	cmp  %g0, %g2                                  
 2009498:	ba 60 3f ff 	subx  %g0, -1, %i5                             
      last = 1;                                                       
    if (first) {                                                      
 200949c:	80 a0 60 00 	cmp  %g1, 0                                    
 20094a0:	02 80 00 08 	be  20094c0 <rtems_mkdir+0xa8>                 
 20094a4:	80 a7 60 00 	cmp  %i5, 0                                    
       *    mkdir [-m mode] dir                                       
       *                                                              
       * We change the user's umask and then restore it,              
       * instead of doing chmod's.                                    
       */                                                             
      oumask = umask(0);                                              
 20094a8:	40 00 0a 28 	call  200bd48 <umask>                          
 20094ac:	90 10 20 00 	clr  %o0                                       
 20094b0:	b0 10 00 08 	mov  %o0, %i0                                  
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
 20094b4:	40 00 0a 25 	call  200bd48 <umask>                          
 20094b8:	90 0a 3f 3f 	and  %o0, -193, %o0                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
 20094bc:	80 a7 60 00 	cmp  %i5, 0                                    
 20094c0:	02 80 00 05 	be  20094d4 <rtems_mkdir+0xbc>                 
 20094c4:	92 10 21 ff 	mov  0x1ff, %o1                                
      (void)umask(oumask);                                            
 20094c8:	40 00 0a 20 	call  200bd48 <umask>                          
 20094cc:	90 10 00 18 	mov  %i0, %o0                                  
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
 20094d0:	92 10 00 19 	mov  %i1, %o1                                  
 20094d4:	7f ff fc 94 	call  2008724 <mkdir>                          
 20094d8:	90 10 00 1b 	mov  %i3, %o0                                  
 20094dc:	80 a2 20 00 	cmp  %o0, 0                                    
 20094e0:	16 80 00 2d 	bge  2009594 <rtems_mkdir+0x17c>               
 20094e4:	80 a7 60 00 	cmp  %i5, 0                                    
      if (errno == EEXIST || errno == EISDIR) {                       
 20094e8:	40 00 5d 4e 	call  2020a20 <__errno>                        
 20094ec:	01 00 00 00 	nop                                            
 20094f0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 20094f4:	80 a0 60 11 	cmp  %g1, 0x11                                 
 20094f8:	12 80 00 09 	bne  200951c <rtems_mkdir+0x104>               
 20094fc:	90 10 00 1b 	mov  %i3, %o0                                  
        if (stat(path, &sb) < 0) {                                    
 2009500:	40 00 00 3d 	call  20095f4 <stat>                           
 2009504:	92 07 bf b8 	add  %fp, -72, %o1                             
 2009508:	80 a2 20 00 	cmp  %o0, 0                                    
 200950c:	16 80 00 0c 	bge  200953c <rtems_mkdir+0x124>               <== ALWAYS TAKEN
 2009510:	c2 07 bf c4 	ld  [ %fp + -60 ], %g1                         
          retval = 0;                                                 
 2009514:	10 80 00 2b 	b  20095c0 <rtems_mkdir+0x1a8>                 <== NOT EXECUTED
 2009518:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
      if (errno == EEXIST || errno == EISDIR) {                       
 200951c:	40 00 5d 41 	call  2020a20 <__errno>                        
 2009520:	01 00 00 00 	nop                                            
 2009524:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 2009528:	80 a0 60 15 	cmp  %g1, 0x15                                 
 200952c:	02 bf ff f5 	be  2009500 <rtems_mkdir+0xe8>                 <== NEVER TAKEN
 2009530:	90 10 00 1b 	mov  %i3, %o0                                  
        if (stat(path, &sb) < 0) {                                    
          retval = 0;                                                 
 2009534:	10 80 00 23 	b  20095c0 <rtems_mkdir+0x1a8>                 
 2009538:	b8 10 20 00 	clr  %i4                                       
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
 200953c:	82 08 40 11 	and  %g1, %l1, %g1                             
 2009540:	80 a0 40 12 	cmp  %g1, %l2                                  
 2009544:	02 80 00 0f 	be  2009580 <rtems_mkdir+0x168>                
 2009548:	80 a7 60 00 	cmp  %i5, 0                                    
          if (last)                                                   
 200954c:	02 80 00 08 	be  200956c <rtems_mkdir+0x154>                
 2009550:	01 00 00 00 	nop                                            
            errno = EEXIST;                                           
 2009554:	40 00 5d 33 	call  2020a20 <__errno>                        
 2009558:	b8 10 20 00 	clr  %i4	! 0 <PROM_START>                      
 200955c:	82 10 20 11 	mov  0x11, %g1                                 
 2009560:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2009564:	10 80 00 17 	b  20095c0 <rtems_mkdir+0x1a8>                 
 2009568:	ba 10 20 01 	mov  1, %i5                                    
          else                                                        
            errno = ENOTDIR;                                          
 200956c:	40 00 5d 2d 	call  2020a20 <__errno>                        
 2009570:	b8 10 20 00 	clr  %i4                                       
 2009574:	82 10 20 14 	mov  0x14, %g1                                 
 2009578:	10 80 00 12 	b  20095c0 <rtems_mkdir+0x1a8>                 
 200957c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
          retval = 0;                                                 
          break;                                                      
        }                                                             
        if (last)                                                     
 2009580:	32 80 00 09 	bne,a   20095a4 <rtems_mkdir+0x18c>            
 2009584:	b8 10 20 02 	mov  2, %i4                                    
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
 2009588:	e0 2e 80 00 	stb  %l0, [ %i2 ]                              
 200958c:	10 80 00 07 	b  20095a8 <rtems_mkdir+0x190>                 
 2009590:	84 10 20 00 	clr  %g2                                       
      } else {                                                        
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
 2009594:	22 bf ff fe 	be,a   200958c <rtems_mkdir+0x174>             
 2009598:	e0 2e 80 00 	stb  %l0, [ %i2 ]                              
          else                                                        
            errno = ENOTDIR;                                          
          retval = 0;                                                 
          break;                                                      
        }                                                             
        if (last)                                                     
 200959c:	10 80 00 03 	b  20095a8 <rtems_mkdir+0x190>                 
 20095a0:	84 10 20 01 	mov  1, %g2                                    
 20095a4:	84 10 20 01 	mov  1, %g2                                    
 20095a8:	82 10 20 00 	clr  %g1                                       
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
 20095ac:	80 a0 a0 00 	cmp  %g2, 0                                    
 20095b0:	02 bf ff ab 	be  200945c <rtems_mkdir+0x44>                 
 20095b4:	b4 06 a0 01 	inc  %i2                                       
 20095b8:	10 80 00 03 	b  20095c4 <rtems_mkdir+0x1ac>                 
 20095bc:	ba 10 20 01 	mov  1, %i5                                    
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
      if (errno == EEXIST || errno == EISDIR) {                       
        if (stat(path, &sb) < 0) {                                    
 20095c0:	82 10 20 00 	clr  %g1                                       
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
 20095c4:	80 97 40 01 	orcc  %i5, %g1, %g0                            
 20095c8:	12 80 00 04 	bne  20095d8 <rtems_mkdir+0x1c0>               
 20095cc:	01 00 00 00 	nop                                            
    (void)umask(oumask);                                              
 20095d0:	40 00 09 de 	call  200bd48 <umask>                          
 20095d4:	90 10 00 18 	mov  %i0, %o0                                  
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
                                                                      
  if (dup_path != NULL) {                                             
    success = build(dup_path, mode);                                  
    free(dup_path);                                                   
 20095d8:	7f ff fa 83 	call  2007fe4 <free>                           
 20095dc:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
 20095e0:	80 a7 20 00 	cmp  %i4, 0                                    
 20095e4:	02 bf ff 93 	be  2009430 <rtems_mkdir+0x18>                 
 20095e8:	01 00 00 00 	nop                                            
}                                                                     
 20095ec:	81 c7 e0 08 	ret                                            
 20095f0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

02008b84 <rtems_partition_create>: uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) {
 2008b84:	9d e3 bf a0 	save  %sp, -96, %sp                            
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
 2008b88:	80 a6 20 00 	cmp  %i0, 0                                    
 2008b8c:	02 80 00 38 	be  2008c6c <rtems_partition_create+0xe8>      
 2008b90:	82 10 20 03 	mov  3, %g1                                    
    return RTEMS_INVALID_NAME;                                        
                                                                      
  if ( !starting_address )                                            
 2008b94:	80 a6 60 00 	cmp  %i1, 0                                    
 2008b98:	02 80 00 35 	be  2008c6c <rtems_partition_create+0xe8>      
 2008b9c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
 2008ba0:	80 a7 60 00 	cmp  %i5, 0                                    
 2008ba4:	02 80 00 32 	be  2008c6c <rtems_partition_create+0xe8>      <== NEVER TAKEN
 2008ba8:	80 a6 e0 00 	cmp  %i3, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
 2008bac:	02 80 00 30 	be  2008c6c <rtems_partition_create+0xe8>      
 2008bb0:	82 10 20 08 	mov  8, %g1                                    
 2008bb4:	80 a6 a0 00 	cmp  %i2, 0                                    
 2008bb8:	02 80 00 2d 	be  2008c6c <rtems_partition_create+0xe8>      
 2008bbc:	80 a6 80 1b 	cmp  %i2, %i3                                  
 2008bc0:	0a 80 00 2b 	bcs  2008c6c <rtems_partition_create+0xe8>     
 2008bc4:	80 8e e0 07 	btst  7, %i3                                   
 2008bc8:	12 80 00 29 	bne  2008c6c <rtems_partition_create+0xe8>     
 2008bcc:	80 8e 60 07 	btst  7, %i1                                   
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
 2008bd0:	12 80 00 27 	bne  2008c6c <rtems_partition_create+0xe8>     
 2008bd4:	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;                  
 2008bd8:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
 2008bdc:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2	! 2022090 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 2008be0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2008be4:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
 *  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 );
 2008be8:	23 00 80 87 	sethi  %hi(0x2021c00), %l1                     
 2008bec:	40 00 07 08 	call  200a80c <_Objects_Allocate>              
 2008bf0:	90 14 62 8c 	or  %l1, 0x28c, %o0	! 2021e8c <_Partition_Information>
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
 2008bf4:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2008bf8:	32 80 00 06 	bne,a   2008c10 <rtems_partition_create+0x8c>  
 2008bfc:	f8 24 20 1c 	st  %i4, [ %l0 + 0x1c ]                        
    _Thread_Enable_dispatch();                                        
 2008c00:	40 00 0c 3a 	call  200bce8 <_Thread_Enable_dispatch>        
 2008c04:	01 00 00 00 	nop                                            
    return RTEMS_TOO_MANY;                                            
 2008c08:	10 80 00 19 	b  2008c6c <rtems_partition_create+0xe8>       
 2008c0c:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               
  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,        
                        length / buffer_size, buffer_size );          
 2008c10:	92 10 00 1b 	mov  %i3, %o1                                  
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
 2008c14:	f2 24 20 10 	st  %i1, [ %l0 + 0x10 ]                        
  the_partition->length                = length;                      
 2008c18:	f4 24 20 14 	st  %i2, [ %l0 + 0x14 ]                        
  the_partition->buffer_size           = buffer_size;                 
 2008c1c:	f6 24 20 18 	st  %i3, [ %l0 + 0x18 ]                        
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
 2008c20:	c0 24 20 20 	clr  [ %l0 + 0x20 ]                            
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
                        length / buffer_size, buffer_size );          
 2008c24:	40 00 46 0e 	call  201a45c <.udiv>                          
 2008c28:	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,        
 2008c2c:	92 10 00 19 	mov  %i1, %o1                                  
                        length / buffer_size, buffer_size );          
 2008c30:	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,        
 2008c34:	96 10 00 1b 	mov  %i3, %o3                                  
 2008c38:	b8 04 20 24 	add  %l0, 0x24, %i4                            
 2008c3c:	40 00 04 74 	call  2009e0c <_Chain_Initialize>              
 2008c40:	90 10 00 1c 	mov  %i4, %o0                                  
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 2008c44:	c4 14 20 0a 	lduh  [ %l0 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 2008c48:	a2 14 62 8c 	or  %l1, 0x28c, %l1                            
 2008c4c:	c6 04 60 1c 	ld  [ %l1 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 2008c50:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 2008c54:	85 28 a0 02 	sll  %g2, 2, %g2                               
 2008c58:	e0 20 c0 02 	st  %l0, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
 2008c5c:	f0 24 20 0c 	st  %i0, [ %l0 + 0xc ]                         
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
 2008c60:	40 00 0c 22 	call  200bce8 <_Thread_Enable_dispatch>        
 2008c64:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  return RTEMS_SUCCESSFUL;                                            
 2008c68:	82 10 20 00 	clr  %g1                                       
}                                                                     
 2008c6c:	81 c7 e0 08 	ret                                            
 2008c70:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02016364 <rtems_partition_return_buffer>: rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) {
 2016364:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (              
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Partition_Control *)                                        
 2016368:	11 00 80 f1 	sethi  %hi(0x203c400), %o0                     
 201636c:	92 10 00 18 	mov  %i0, %o1                                  
 2016370:	90 12 23 ac 	or  %o0, 0x3ac, %o0                            
 2016374:	40 00 14 2b 	call  201b420 <_Objects_Get>                   
 2016378:	94 07 bf fc 	add  %fp, -4, %o2                              
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
 201637c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2016380:	80 a0 60 00 	cmp  %g1, 0                                    
 2016384:	12 80 00 21 	bne  2016408 <rtems_partition_return_buffer+0xa4>
 2016388:	ba 10 00 08 	mov  %o0, %i5                                  
)                                                                     
{                                                                     
  void *starting;                                                     
  void *ending;                                                       
                                                                      
  starting = the_partition->starting_address;                         
 201638c:	d0 02 20 10 	ld  [ %o0 + 0x10 ], %o0                        
 2016390:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2016394:	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 ) &&         
 2016398:	80 a6 40 01 	cmp  %i1, %g1                                  
 201639c:	18 80 00 0b 	bgu  20163c8 <rtems_partition_return_buffer+0x64><== NEVER TAKEN
 20163a0:	82 10 20 00 	clr  %g1                                       
 20163a4:	80 a6 40 08 	cmp  %i1, %o0                                  
 20163a8:	0a 80 00 09 	bcs  20163cc <rtems_partition_return_buffer+0x68>
 20163ac:	80 a0 60 00 	cmp  %g1, 0                                    
  offset = (uint32_t) _Addresses_Subtract(                            
    the_buffer,                                                       
    the_partition->starting_address                                   
  );                                                                  
                                                                      
  return ((offset % the_partition->buffer_size) == 0);                
 20163b0:	d2 07 60 18 	ld  [ %i5 + 0x18 ], %o1                        
 20163b4:	40 00 58 13 	call  202c400 <.urem>                          
 20163b8:	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 ) &&         
 20163bc:	80 a0 00 08 	cmp  %g0, %o0                                  
 20163c0:	10 80 00 02 	b  20163c8 <rtems_partition_return_buffer+0x64>
 20163c4:	82 60 3f ff 	subx  %g0, -1, %g1                             
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {    
 20163c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20163cc:	02 80 00 0b 	be  20163f8 <rtems_partition_return_buffer+0x94>
 20163d0:	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 );                
 20163d4:	40 00 0c 98 	call  2019634 <_Chain_Append>                  
 20163d8:	92 10 00 19 	mov  %i1, %o1                                  
        _Partition_Free_buffer( the_partition, buffer );              
        the_partition->number_of_used_blocks -= 1;                    
 20163dc:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
 20163e0:	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;                    
 20163e4:	82 00 7f ff 	add  %g1, -1, %g1                              
        _Thread_Enable_dispatch();                                    
 20163e8:	40 00 17 f0 	call  201c3a8 <_Thread_Enable_dispatch>        
 20163ec:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
 20163f0:	81 c7 e0 08 	ret                                            
 20163f4:	81 e8 00 00 	restore                                        
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
      _Thread_Enable_dispatch();                                      
 20163f8:	40 00 17 ec 	call  201c3a8 <_Thread_Enable_dispatch>        
 20163fc:	b0 10 20 09 	mov  9, %i0                                    
 2016400:	81 c7 e0 08 	ret                                            
 2016404:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 2016408:	81 c7 e0 08 	ret                                            
 201640c:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      

02033028 <rtems_rate_monotonic_period>: rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) {
 2033028:	9d e3 bf 98 	save  %sp, -104, %sp                           
 203302c:	11 00 81 8a 	sethi  %hi(0x2062800), %o0                     
 2033030:	92 10 00 18 	mov  %i0, %o1                                  
 2033034:	90 12 23 24 	or  %o0, 0x324, %o0                            
 2033038:	7f ff 57 6f 	call  2008df4 <_Objects_Get>                   
 203303c:	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 ) {                                               
 2033040:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2033044:	80 a0 60 00 	cmp  %g1, 0                                    
 2033048:	12 80 00 6a 	bne  20331f0 <rtems_rate_monotonic_period+0x1c8>
 203304c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
 2033050:	37 00 81 89 	sethi  %hi(0x2062400), %i3                     
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
 2033054:	c4 02 20 40 	ld  [ %o0 + 0x40 ], %g2                        
 2033058:	b6 16 e1 60 	or  %i3, 0x160, %i3                            
 203305c:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
 2033060:	80 a0 80 01 	cmp  %g2, %g1                                  
 2033064:	02 80 00 06 	be  203307c <rtems_rate_monotonic_period+0x54> 
 2033068:	80 a6 60 00 	cmp  %i1, 0                                    
        _Thread_Enable_dispatch();                                    
 203306c:	7f ff 5b 1a 	call  2009cd4 <_Thread_Enable_dispatch>        
 2033070:	b0 10 20 17 	mov  0x17, %i0                                 
 2033074:	81 c7 e0 08 	ret                                            
 2033078:	81 e8 00 00 	restore                                        
        return RTEMS_NOT_OWNER_OF_RESOURCE;                           
      }                                                               
                                                                      
      if ( length == RTEMS_PERIOD_STATUS ) {                          
 203307c:	12 80 00 0d 	bne  20330b0 <rtems_rate_monotonic_period+0x88>
 2033080:	01 00 00 00 	nop                                            
        switch ( the_period->state ) {                                
 2033084:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 2033088:	80 a0 60 04 	cmp  %g1, 4                                    
 203308c:	18 80 00 05 	bgu  20330a0 <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
 2033090:	b0 10 20 00 	clr  %i0                                       
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 2033094:	05 00 81 6f 	sethi  %hi(0x205bc00), %g2                     
 2033098:	84 10 a1 90 	or  %g2, 0x190, %g2	! 205bd90 <CSWTCH.24>      
 203309c:	f0 08 80 01 	ldub  [ %g2 + %g1 ], %i0                       
          case RATE_MONOTONIC_ACTIVE:                                 
          default:              /* unreached -- only to remove warnings */
            return_value = RTEMS_SUCCESSFUL;                          
            break;                                                    
        }                                                             
        _Thread_Enable_dispatch();                                    
 20330a0:	7f ff 5b 0d 	call  2009cd4 <_Thread_Enable_dispatch>        
 20330a4:	01 00 00 00 	nop                                            
 20330a8:	81 c7 e0 08 	ret                                            
 20330ac:	81 e8 00 00 	restore                                        
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
 20330b0:	7f ff 3c a8 	call  2002350 <sparc_disable_interrupts>       
 20330b4:	01 00 00 00 	nop                                            
 20330b8:	b4 10 00 08 	mov  %o0, %i2                                  
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
 20330bc:	f8 07 60 38 	ld  [ %i5 + 0x38 ], %i4                        
 20330c0:	80 a7 20 00 	cmp  %i4, 0                                    
 20330c4:	12 80 00 15 	bne  2033118 <rtems_rate_monotonic_period+0xf0>
 20330c8:	80 a7 20 02 	cmp  %i4, 2                                    
        _ISR_Enable( level );                                         
 20330cc:	7f ff 3c a5 	call  2002360 <sparc_enable_interrupts>        
 20330d0:	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 );            
 20330d4:	90 10 00 1d 	mov  %i5, %o0                                  
 20330d8:	7f ff ff b8 	call  2032fb8 <_Rate_monotonic_Initiate_statistics>
 20330dc:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
 20330e0:	82 10 20 02 	mov  2, %g1                                    
 20330e4:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
 20330e8:	03 00 80 cc 	sethi  %hi(0x2033000), %g1                     
 20330ec:	82 10 61 fc 	or  %g1, 0x1fc, %g1	! 20331fc <_Rate_monotonic_Timeout>
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 20330f0:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
 20330f4:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
  the_watchdog->id        = id;                                       
 20330f8:	f0 27 60 30 	st  %i0, [ %i5 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
 20330fc:	c0 27 60 34 	clr  [ %i5 + 0x34 ]                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 2033100:	f2 27 60 1c 	st  %i1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 2033104:	11 00 81 88 	sethi  %hi(0x2062000), %o0                     
 2033108:	92 07 60 10 	add  %i5, 0x10, %o1                            
 203310c:	7f ff 5e 17 	call  200a968 <_Watchdog_Insert>               
 2033110:	90 12 20 dc 	or  %o0, 0xdc, %o0                             
 2033114:	30 80 00 1b 	b,a   2033180 <rtems_rate_monotonic_period+0x158>
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
 2033118:	12 80 00 1e 	bne  2033190 <rtems_rate_monotonic_period+0x168>
 203311c:	80 a7 20 04 	cmp  %i4, 4                                    
        /*                                                            
         *  Update statistics from the concluding period.             
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
 2033120:	7f ff ff 5d 	call  2032e94 <_Rate_monotonic_Update_statistics>
 2033124:	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;         
 2033128:	82 10 20 01 	mov  1, %g1                                    
        the_period->next_length = length;                             
 203312c:	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;         
 2033130:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
        the_period->next_length = length;                             
                                                                      
        _ISR_Enable( level );                                         
 2033134:	7f ff 3c 8b 	call  2002360 <sparc_enable_interrupts>        
 2033138:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
 203313c:	d0 06 e0 10 	ld  [ %i3 + 0x10 ], %o0                        
 2033140:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
 2033144:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
 2033148:	7f ff 5d 1b 	call  200a5b4 <_Thread_Set_state>              
 203314c:	c2 22 20 20 	st  %g1, [ %o0 + 0x20 ]                        
                                                                      
        /*                                                            
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
 2033150:	7f ff 3c 80 	call  2002350 <sparc_disable_interrupts>       
 2033154:	01 00 00 00 	nop                                            
          local_state = the_period->state;                            
 2033158:	f4 07 60 38 	ld  [ %i5 + 0x38 ], %i2                        
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
 203315c:	f8 27 60 38 	st  %i4, [ %i5 + 0x38 ]                        
        _ISR_Enable( level );                                         
 2033160:	7f ff 3c 80 	call  2002360 <sparc_enable_interrupts>        
 2033164:	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 )   
 2033168:	80 a6 a0 03 	cmp  %i2, 3                                    
 203316c:	12 80 00 05 	bne  2033180 <rtems_rate_monotonic_period+0x158>
 2033170:	01 00 00 00 	nop                                            
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
 2033174:	d0 06 e0 10 	ld  [ %i3 + 0x10 ], %o0                        
 2033178:	7f ff 59 e9 	call  200991c <_Thread_Clear_state>            
 203317c:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
                                                                      
        _Thread_Enable_dispatch();                                    
 2033180:	7f ff 5a d5 	call  2009cd4 <_Thread_Enable_dispatch>        
 2033184:	b0 10 20 00 	clr  %i0                                       
 2033188:	81 c7 e0 08 	ret                                            
 203318c:	81 e8 00 00 	restore                                        
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {            
 2033190:	12 bf ff b9 	bne  2033074 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
 2033194:	b0 10 20 04 	mov  4, %i0                                    
        /*                                                            
         *  Update statistics from the concluding period              
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
 2033198:	7f ff ff 3f 	call  2032e94 <_Rate_monotonic_Update_statistics>
 203319c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
        _ISR_Enable( level );                                         
 20331a0:	7f ff 3c 70 	call  2002360 <sparc_enable_interrupts>        
 20331a4:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
 20331a8:	82 10 20 02 	mov  2, %g1                                    
 20331ac:	92 07 60 10 	add  %i5, 0x10, %o1                            
 20331b0:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
        the_period->next_length = length;                             
 20331b4:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 20331b8:	f2 27 60 1c 	st  %i1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 20331bc:	11 00 81 88 	sethi  %hi(0x2062000), %o0                     
 20331c0:	7f ff 5d ea 	call  200a968 <_Watchdog_Insert>               
 20331c4:	90 12 20 dc 	or  %o0, 0xdc, %o0	! 20620dc <_Watchdog_Ticks_chain>
 20331c8:	d0 07 60 40 	ld  [ %i5 + 0x40 ], %o0                        
 20331cc:	d2 07 60 3c 	ld  [ %i5 + 0x3c ], %o1                        
 20331d0:	03 00 81 77 	sethi  %hi(0x205dc00), %g1                     
 20331d4:	c2 00 61 04 	ld  [ %g1 + 0x104 ], %g1	! 205dd04 <_Scheduler+0x34>
 20331d8:	9f c0 40 00 	call  %g1                                      
 20331dc:	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();                                    
 20331e0:	7f ff 5a bd 	call  2009cd4 <_Thread_Enable_dispatch>        
 20331e4:	01 00 00 00 	nop                                            
 20331e8:	81 c7 e0 08 	ret                                            
 20331ec:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
 20331f0:	b0 10 20 04 	mov  4, %i0                                    
}                                                                     
 20331f4:	81 c7 e0 08 	ret                                            
 20331f8:	81 e8 00 00 	restore                                        
                                                                      

020262f0 <rtems_rate_monotonic_report_statistics_with_plugin>: void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
 20262f0:	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 )                                                       
 20262f4:	80 a6 60 00 	cmp  %i1, 0                                    
 20262f8:	02 80 00 75 	be  20264cc <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
 20262fc:	90 10 00 18 	mov  %i0, %o0                                  
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
 2026300:	13 00 81 63 	sethi  %hi(0x2058c00), %o1                     
 2026304:	9f c6 40 00 	call  %i1                                      
 2026308:	92 12 63 e8 	or  %o1, 0x3e8, %o1	! 2058fe8 <_TOD_Days_per_month+0x68>
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
 202630c:	90 10 00 18 	mov  %i0, %o0                                  
 2026310:	13 00 81 64 	sethi  %hi(0x2059000), %o1                     
 2026314:	9f c6 40 00 	call  %i1                                      
 2026318:	92 12 60 08 	or  %o1, 8, %o1	! 2059008 <_TOD_Days_per_month+0x88>
    (*print)( context, "--- Wall times are in seconds ---\n" );       
 202631c:	90 10 00 18 	mov  %i0, %o0                                  
 2026320:	13 00 81 64 	sethi  %hi(0x2059000), %o1                     
 2026324:	9f c6 40 00 	call  %i1                                      
 2026328:	92 12 60 30 	or  %o1, 0x30, %o1	! 2059030 <_TOD_Days_per_month+0xb0>
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
 202632c:	90 10 00 18 	mov  %i0, %o0                                  
 2026330:	13 00 81 64 	sethi  %hi(0x2059000), %o1                     
 2026334:	9f c6 40 00 	call  %i1                                      
 2026338:	92 12 60 58 	or  %o1, 0x58, %o1	! 2059058 <_TOD_Days_per_month+0xd8>
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
 202633c:	90 10 00 18 	mov  %i0, %o0                                  
 2026340:	13 00 81 64 	sethi  %hi(0x2059000), %o1                     
 2026344:	9f c6 40 00 	call  %i1                                      
 2026348:	92 12 60 a8 	or  %o1, 0xa8, %o1	! 20590a8 <_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 ;                   
 202634c:	03 00 81 8a 	sethi  %hi(0x2062800), %g1                     
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
 2026350:	39 00 81 64 	sethi  %hi(0x2059000), %i4                     
      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,                                              
 2026354:	37 00 81 64 	sethi  %hi(0x2059000), %i3                     
      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,                                              
 2026358:	35 00 81 64 	sethi  %hi(0x2059000), %i2                     
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
 202635c:	21 00 81 69 	sethi  %hi(0x205a400), %l0                     
                                                                      
  /*                                                                  
   * 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 ;                   
 2026360:	fa 00 63 2c 	ld  [ %g1 + 0x32c ], %i5                       
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
 2026364:	b8 17 20 f8 	or  %i4, 0xf8, %i4                             
      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,                                              
 2026368:	b6 16 e1 10 	or  %i3, 0x110, %i3                            
      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,                                              
 202636c:	b4 16 a1 30 	or  %i2, 0x130, %i2                            
                                                                      
  /*                                                                  
   * 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 ;                   
 2026370:	10 80 00 52 	b  20264b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
 2026374:	a0 14 21 b8 	or  %l0, 0x1b8, %l0                            
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
 2026378:	40 00 31 e9 	call  2032b1c <rtems_rate_monotonic_get_statistics>
 202637c:	92 07 bf c8 	add  %fp, -56, %o1                             
    if ( status != RTEMS_SUCCESSFUL )                                 
 2026380:	80 a2 20 00 	cmp  %o0, 0                                    
 2026384:	32 80 00 4d 	bne,a   20264b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
 2026388:	ba 07 60 01 	inc  %i5                                       
    #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 );      
 202638c:	92 07 bf b0 	add  %fp, -80, %o1                             
 2026390:	40 00 32 54 	call  2032ce0 <rtems_rate_monotonic_get_status>
 2026394:	90 10 00 1d 	mov  %i5, %o0                                  
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
 2026398:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
 202639c:	92 10 20 05 	mov  5, %o1                                    
 20263a0:	7f ff a2 bc 	call  200ee90 <rtems_object_get_name>          
 20263a4:	94 07 bf a0 	add  %fp, -96, %o2                             
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
 20263a8:	d8 1f bf c8 	ldd  [ %fp + -56 ], %o4                        
 20263ac:	92 10 00 1c 	mov  %i4, %o1                                  
 20263b0:	90 10 00 18 	mov  %i0, %o0                                  
 20263b4:	94 10 00 1d 	mov  %i5, %o2                                  
 20263b8:	9f c6 40 00 	call  %i1                                      
 20263bc:	96 07 bf a0 	add  %fp, -96, %o3                             
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
 20263c0:	d2 07 bf c8 	ld  [ %fp + -56 ], %o1                         
 20263c4:	80 a2 60 00 	cmp  %o1, 0                                    
 20263c8:	12 80 00 07 	bne  20263e4 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
 20263cc:	94 07 bf a8 	add  %fp, -88, %o2                             
      (*print)( context, "\n" );                                      
 20263d0:	90 10 00 18 	mov  %i0, %o0                                  
 20263d4:	9f c6 40 00 	call  %i1                                      
 20263d8:	92 10 00 10 	mov  %l0, %o1                                  
      continue;                                                       
 20263dc:	10 80 00 37 	b  20264b8 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
 20263e0:	ba 07 60 01 	inc  %i5                                       
      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 );
 20263e4:	40 00 02 b7 	call  2026ec0 <_Timespec_Divide_by_integer>    
 20263e8:	90 07 bf e0 	add  %fp, -32, %o0                             
      (*print)( context,                                              
 20263ec:	d0 07 bf d4 	ld  [ %fp + -44 ], %o0                         
 20263f0:	40 00 a6 ac 	call  204fea0 <.div>                           
 20263f4:	92 10 23 e8 	mov  0x3e8, %o1                                
 20263f8:	a6 10 00 08 	mov  %o0, %l3                                  
 20263fc:	d0 07 bf dc 	ld  [ %fp + -36 ], %o0                         
 2026400:	40 00 a6 a8 	call  204fea0 <.div>                           
 2026404:	92 10 23 e8 	mov  0x3e8, %o1                                
 2026408:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
 202640c:	a2 10 00 08 	mov  %o0, %l1                                  
 2026410:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
 2026414:	e8 07 bf d0 	ld  [ %fp + -48 ], %l4                         
 2026418:	e4 07 bf d8 	ld  [ %fp + -40 ], %l2                         
 202641c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 2026420:	40 00 a6 a0 	call  204fea0 <.div>                           
 2026424:	92 10 23 e8 	mov  0x3e8, %o1                                
 2026428:	96 10 00 13 	mov  %l3, %o3                                  
 202642c:	98 10 00 12 	mov  %l2, %o4                                  
 2026430:	9a 10 00 11 	mov  %l1, %o5                                  
 2026434:	94 10 00 14 	mov  %l4, %o2                                  
 2026438:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
 202643c:	92 10 00 1b 	mov  %i3, %o1                                  
 2026440:	9f c6 40 00 	call  %i1                                      
 2026444:	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);
 2026448:	d2 07 bf c8 	ld  [ %fp + -56 ], %o1                         
 202644c:	94 07 bf a8 	add  %fp, -88, %o2                             
 2026450:	40 00 02 9c 	call  2026ec0 <_Timespec_Divide_by_integer>    
 2026454:	90 07 bf f8 	add  %fp, -8, %o0                              
      (*print)( context,                                              
 2026458:	d0 07 bf ec 	ld  [ %fp + -20 ], %o0                         
 202645c:	40 00 a6 91 	call  204fea0 <.div>                           
 2026460:	92 10 23 e8 	mov  0x3e8, %o1                                
 2026464:	a6 10 00 08 	mov  %o0, %l3                                  
 2026468:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
 202646c:	40 00 a6 8d 	call  204fea0 <.div>                           
 2026470:	92 10 23 e8 	mov  0x3e8, %o1                                
 2026474:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
 2026478:	a2 10 00 08 	mov  %o0, %l1                                  
 202647c:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
 2026480:	e8 07 bf e8 	ld  [ %fp + -24 ], %l4                         
 2026484:	e4 07 bf f0 	ld  [ %fp + -16 ], %l2                         
 2026488:	92 10 23 e8 	mov  0x3e8, %o1                                
 202648c:	40 00 a6 85 	call  204fea0 <.div>                           
 2026490:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 2026494:	92 10 00 1a 	mov  %i2, %o1                                  
 2026498:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
 202649c:	94 10 00 14 	mov  %l4, %o2                                  
 20264a0:	90 10 00 18 	mov  %i0, %o0                                  
 20264a4:	96 10 00 13 	mov  %l3, %o3                                  
 20264a8:	98 10 00 12 	mov  %l2, %o4                                  
 20264ac:	9f c6 40 00 	call  %i1                                      
 20264b0:	9a 10 00 11 	mov  %l1, %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 ;                   
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
 20264b4:	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 ;                   
        id <= _Rate_monotonic_Information.maximum_id ;                
 20264b8:	03 00 81 8a 	sethi  %hi(0x2062800), %g1                     
                                                                      
  /*                                                                  
   * 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 ;                   
 20264bc:	c2 00 63 30 	ld  [ %g1 + 0x330 ], %g1	! 2062b30 <_Rate_monotonic_Information+0xc>
 20264c0:	80 a7 40 01 	cmp  %i5, %g1                                  
 20264c4:	08 bf ff ad 	bleu  2026378 <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
 20264c8:	90 10 00 1d 	mov  %i5, %o0                                  
 20264cc:	81 c7 e0 08 	ret                                            
 20264d0:	81 e8 00 00 	restore                                        
                                                                      

020088a4 <rtems_rbheap_allocate>: return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) {
 20088a4:	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;                           
 20088a8:	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;                               
 20088ac:	90 10 00 19 	mov  %i1, %o0                                  
 20088b0:	92 10 00 1d 	mov  %i5, %o1                                  
 20088b4:	40 00 44 7e 	call  2019aac <.urem>                          
 20088b8:	b6 10 00 19 	mov  %i1, %i3                                  
                                                                      
  if (excess > 0) {                                                   
 20088bc:	80 a2 20 00 	cmp  %o0, 0                                    
 20088c0:	02 80 00 05 	be  20088d4 <rtems_rbheap_allocate+0x30>       <== ALWAYS TAKEN
 20088c4:	80 a6 c0 19 	cmp  %i3, %i1                                  
    value += alignment - excess;                                      
 20088c8:	b6 06 40 1d 	add  %i1, %i5, %i3                             <== NOT EXECUTED
 20088cc:	b6 26 c0 08 	sub  %i3, %o0, %i3                             <== 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) {                             
 20088d0:	80 a6 c0 19 	cmp  %i3, %i1                                  <== NOT EXECUTED
 20088d4:	0a 80 00 04 	bcs  20088e4 <rtems_rbheap_allocate+0x40>      <== NEVER TAKEN
 20088d8:	80 a6 60 00 	cmp  %i1, 0                                    
 20088dc:	32 80 00 04 	bne,a   20088ec <rtems_rbheap_allocate+0x48>   
 20088e0:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  return big_enough;                                                  
}                                                                     
                                                                      
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{                                                                     
  void *ptr = NULL;                                                   
 20088e4:	81 c7 e0 08 	ret                                            
 20088e8:	91 e8 20 00 	restore  %g0, 0, %o0                           
  rtems_chain_control *free_chain,                                    
  size_t size                                                         
)                                                                     
{                                                                     
  rtems_chain_node *current = rtems_chain_first(free_chain);          
  const rtems_chain_node *tail = rtems_chain_tail(free_chain);        
 20088ec:	84 06 20 04 	add  %i0, 4, %g2                               
  rtems_rbheap_chunk *big_enough = NULL;                              
 20088f0:	10 80 00 06 	b  2008908 <rtems_rbheap_allocate+0x64>        
 20088f4:	ba 10 20 00 	clr  %i5                                       
                                                                      
  while (current != tail && big_enough == NULL) {                     
    rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;  
                                                                      
    if (free_chunk->size >= size) {                                   
 20088f8:	80 a0 c0 1b 	cmp  %g3, %i3                                  
 20088fc:	ba 40 3f ff 	addx  %g0, -1, %i5                             
 2008900:	ba 08 40 1d 	and  %g1, %i5, %i5                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
 2008904:	c2 00 40 00 	ld  [ %g1 ], %g1                               
{                                                                     
  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) {                     
 2008908:	80 a7 60 00 	cmp  %i5, 0                                    
 200890c:	12 80 00 04 	bne  200891c <rtems_rbheap_allocate+0x78>      
 2008910:	80 a0 40 02 	cmp  %g1, %g2                                  
 2008914:	32 bf ff f9 	bne,a   20088f8 <rtems_rbheap_allocate+0x54>   
 2008918:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
  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) {                                         
 200891c:	80 a7 60 00 	cmp  %i5, 0                                    
 2008920:	02 bf ff f1 	be  20088e4 <rtems_rbheap_allocate+0x40>       
 2008924:	01 00 00 00 	nop                                            
      uintptr_t free_size = free_chunk->size;                         
 2008928:	f4 07 60 1c 	ld  [ %i5 + 0x1c ], %i2                        
                                                                      
      if (free_size > aligned_size) {                                 
 200892c:	80 a6 80 1b 	cmp  %i2, %i3                                  
 2008930:	28 80 00 14 	bleu,a   2008980 <rtems_rbheap_allocate+0xdc>  
 2008934:	c4 07 40 00 	ld  [ %i5 ], %g2                               
        rtems_rbheap_chunk *new_chunk = get_chunk(control);           
 2008938:	7f ff ff 80 	call  2008738 <get_chunk>                      
 200893c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
        if (new_chunk != NULL) {                                      
 2008940:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2008944:	02 bf ff e8 	be  20088e4 <rtems_rbheap_allocate+0x40>       <== NEVER TAKEN
 2008948:	b4 26 80 1b 	sub  %i2, %i3, %i2                             
          uintptr_t new_free_size = free_size - aligned_size;         
                                                                      
          free_chunk->size = new_free_size;                           
          new_chunk->begin = free_chunk->begin + new_free_size;       
 200894c:	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;                           
 2008950:	f4 27 60 1c 	st  %i2, [ %i5 + 0x1c ]                        
          new_chunk->begin = free_chunk->begin + new_free_size;       
          new_chunk->size = aligned_size;                             
 2008954:	f6 27 20 1c 	st  %i3, [ %i4 + 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;       
 2008958:	b4 06 80 01 	add  %i2, %g1, %i2                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
 200895c:	c0 27 20 04 	clr  [ %i4 + 4 ]                               
 2008960:	f4 27 20 18 	st  %i2, [ %i4 + 0x18 ]                        
 2008964:	c0 27 00 00 	clr  [ %i4 ]                                   
static void insert_into_tree(                                         
  rtems_rbtree_control *tree,                                         
  rtems_rbheap_chunk *chunk                                           
)                                                                     
{                                                                     
  _RBTree_Insert_unprotected(tree, &chunk->tree_node);                
 2008968:	90 06 20 18 	add  %i0, 0x18, %o0                            
 200896c:	40 00 06 b6 	call  200a444 <_RBTree_Insert_unprotected>     
 2008970:	92 07 20 08 	add  %i4, 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;                            
 2008974:	f0 07 20 18 	ld  [ %i4 + 0x18 ], %i0                        
 2008978:	81 c7 e0 08 	ret                                            
 200897c:	81 e8 00 00 	restore                                        
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
 2008980:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
        }                                                             
      } else {                                                        
        rtems_chain_extract_unprotected(&free_chunk->chain_node);     
        rtems_chain_set_off_chain(&free_chunk->chain_node);           
        ptr = (void *) free_chunk->begin;                             
 2008984:	f0 07 60 18 	ld  [ %i5 + 0x18 ], %i0                        
  next->previous = previous;                                          
 2008988:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
 200898c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
 2008990:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
 2008994:	c0 27 40 00 	clr  [ %i5 ]                                   
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return ptr;                                                         
}                                                                     
 2008998:	81 c7 e0 08 	ret                                            
 200899c:	81 e8 00 00 	restore                                        
                                                                      

02008ad0 <rtems_rbheap_extend_descriptors_with_malloc>: /* Do nothing */ } void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) {
 2008ad0:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));                 
 2008ad4:	7f ff ed 5d 	call  2004048 <malloc>                         <== NOT EXECUTED
 2008ad8:	90 10 20 20 	mov  0x20, %o0                                 <== NOT EXECUTED
                                                                      
  if (chunk != NULL) {                                                
 2008adc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2008ae0:	02 80 00 07 	be  2008afc <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
 2008ae4:	82 06 20 0c 	add  %i0, 0xc, %g1                             <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
 2008ae8:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           <== NOT EXECUTED
  before_node           = after_node->next;                           
 2008aec:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         <== NOT EXECUTED
  after_node->next      = the_node;                                   
 2008af0:	d0 26 20 0c 	st  %o0, [ %i0 + 0xc ]                         <== NOT EXECUTED
  the_node->next        = before_node;                                
 2008af4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  before_node->previous = the_node;                                   
 2008af8:	d0 20 60 04 	st  %o0, [ %g1 + 4 ]                           <== NOT EXECUTED
 2008afc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2008b00:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020089a0 <rtems_rbheap_free>: _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) {
 20089a0:	9d e3 bf 80 	save  %sp, -128, %sp                           
 20089a4:	b6 10 00 18 	mov  %i0, %i3                                  
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (ptr != NULL) {                                                  
 20089a8:	80 a6 60 00 	cmp  %i1, 0                                    
 20089ac:	02 80 00 45 	be  2008ac0 <rtems_rbheap_free+0x120>          
 20089b0:	b0 10 20 00 	clr  %i0                                       
                                                                      
#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 };                        
 20089b4:	90 07 bf e0 	add  %fp, -32, %o0                             
 20089b8:	92 10 20 00 	clr  %o1                                       
 20089bc:	94 10 20 20 	mov  0x20, %o2                                 
 20089c0:	40 00 22 7e 	call  20113b8 <memset>                         
 20089c4:	b4 06 e0 18 	add  %i3, 0x18, %i2                            
    RBTree_Control *the_rbtree,                                       
    RBTree_Node *the_node                                             
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
 20089c8:	ba 10 20 00 	clr  %i5                                       
 20089cc:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(           
    RBTree_Control *the_rbtree,                                       
    RBTree_Node *the_node                                             
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
 20089d0:	10 80 00 12 	b  2008a18 <rtems_rbheap_free+0x78>            
 20089d4:	f8 06 e0 1c 	ld  [ %i3 + 0x1c ], %i4                        
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
    compare_result = the_rbtree->compare_function(the_node, iter_node);
 20089d8:	90 07 bf e8 	add  %fp, -24, %o0                             
 20089dc:	9f c0 40 00 	call  %g1                                      
 20089e0:	92 10 00 1c 	mov  %i4, %o1                                  
    if ( _RBTree_Is_equal( compare_result ) ) {                       
 20089e4:	80 a2 20 00 	cmp  %o0, 0                                    
 20089e8:	12 80 00 07 	bne  2008a04 <rtems_rbheap_free+0x64>          
 20089ec:	83 3a 20 1f 	sra  %o0, 0x1f, %g1                            
      found = iter_node;                                              
      if ( the_rbtree->is_unique )                                    
 20089f0:	c2 0e a0 14 	ldub  [ %i2 + 0x14 ], %g1                      
 20089f4:	80 a0 60 00 	cmp  %g1, 0                                    
 20089f8:	12 80 00 0c 	bne  2008a28 <rtems_rbheap_free+0x88>          <== ALWAYS TAKEN
 20089fc:	ba 10 00 1c 	mov  %i4, %i5                                  
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
 2008a00:	83 3a 20 1f 	sra  %o0, 0x1f, %g1                            <== NOT EXECUTED
 2008a04:	90 20 40 08 	sub  %g1, %o0, %o0                             
 2008a08:	91 32 20 1f 	srl  %o0, 0x1f, %o0                            
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
 2008a0c:	91 2a 20 02 	sll  %o0, 2, %o0                               
 2008a10:	b8 07 00 08 	add  %i4, %o0, %i4                             
 2008a14:	f8 07 20 04 	ld  [ %i4 + 4 ], %i4                           
    )                                                                 
{                                                                     
  RBTree_Node* iter_node = the_rbtree->root;                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
 2008a18:	80 a7 20 00 	cmp  %i4, 0                                    
 2008a1c:	32 bf ff ef 	bne,a   20089d8 <rtems_rbheap_free+0x38>       
 2008a20:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
 2008a24:	b8 10 00 1d 	mov  %i5, %i4                                  
                                                                      
  return rtems_rbheap_chunk_of_node(                                  
 2008a28:	ba 07 3f f8 	add  %i4, -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) {                                         
 2008a2c:	80 a7 7f f8 	cmp  %i5, -8                                   
 2008a30:	02 80 00 24 	be  2008ac0 <rtems_rbheap_free+0x120>          
 2008a34:	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);            
 2008a38:	c4 07 3f f8 	ld  [ %i4 + -8 ], %g2                          
 2008a3c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2008a40:	12 80 00 05 	bne  2008a54 <rtems_rbheap_free+0xb4>          
 2008a44:	82 10 20 00 	clr  %g1                                       
 2008a48:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 2008a4c:	80 a0 00 01 	cmp  %g0, %g1                                  
 2008a50:	82 60 3f ff 	subx  %g0, -1, %g1                             
      if (!rtems_rbheap_is_chunk_free(chunk)) {                       
 2008a54:	80 a0 60 00 	cmp  %g1, 0                                    
 2008a58:	02 80 00 1a 	be  2008ac0 <rtems_rbheap_free+0x120>          
 2008a5c:	b0 10 20 0e 	mov  0xe, %i0                                  
static rtems_rbheap_chunk *get_next(                                  
  const rtems_rbheap_chunk *chunk,                                    
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return rtems_rbheap_chunk_of_node(                                  
 2008a60:	b8 07 60 08 	add  %i5, 8, %i4                               
 2008a64:	92 10 20 00 	clr  %o1                                       
 2008a68:	40 00 07 1c 	call  200a6d8 <_RBTree_Next_unprotected>       
 2008a6c:	90 10 00 1c 	mov  %i4, %o0                                  
 2008a70:	92 10 20 01 	mov  1, %o1                                    
 2008a74:	b2 10 00 08 	mov  %o0, %i1                                  
 2008a78:	40 00 07 18 	call  200a6d8 <_RBTree_Next_unprotected>       
 2008a7c:	90 10 00 1c 	mov  %i4, %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);         
 2008a80:	92 10 00 1a 	mov  %i2, %o1                                  
static rtems_rbheap_chunk *get_next(                                  
  const rtems_rbheap_chunk *chunk,                                    
  RBTree_Direction dir                                                
)                                                                     
{                                                                     
  return rtems_rbheap_chunk_of_node(                                  
 2008a84:	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);         
 2008a88:	94 10 00 1d 	mov  %i5, %o2                                  
 2008a8c:	7f ff ff 02 	call  2008694 <check_and_merge>                
 2008a90:	90 10 00 1b 	mov  %i3, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
 2008a94:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
 2008a98:	f6 27 60 04 	st  %i3, [ %i5 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
 2008a9c:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
  the_node->next        = before_node;                                
 2008aa0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  before_node->previous = the_node;                                   
 2008aa4:	fa 20 60 04 	st  %i5, [ %g1 + 4 ]                           
        add_to_chain(free_chain, chunk);                              
        check_and_merge(free_chain, chunk_tree, chunk, pred);         
 2008aa8:	90 10 00 1b 	mov  %i3, %o0                                  
 2008aac:	92 10 00 1a 	mov  %i2, %o1                                  
 2008ab0:	94 10 00 1d 	mov  %i5, %o2                                  
 2008ab4:	96 06 7f f8 	add  %i1, -8, %o3                              
 2008ab8:	7f ff fe f7 	call  2008694 <check_and_merge>                
 2008abc:	b0 10 20 00 	clr  %i0                                       
      sc = RTEMS_INVALID_ID;                                          
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 2008ac0:	81 c7 e0 08 	ret                                            
 2008ac4:	81 e8 00 00 	restore                                        
                                                                      

02019830 <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) {
 2019830:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
 2019834:	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)             
{                                                                     
 2019838:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
 201983c:	80 a0 60 00 	cmp  %g1, 0                                    
 2019840:	02 80 00 0f 	be  201987c <rtems_rfs_bitmap_load_map+0x4c>   
 2019844:	b0 10 20 06 	mov  6, %i0                                    
    return ENXIO;                                                     
                                                                      
  *map = NULL;                                                        
 2019848:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (control->fs,                  
 201984c:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
 2019850:	d0 07 60 04 	ld  [ %i5 + 4 ], %o0                           
 2019854:	d2 07 40 00 	ld  [ %i5 ], %o1                               
 2019858:	40 00 06 e8 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201985c:	96 10 20 01 	mov  1, %o3                                    
                                        control->buffer,              
                                        control->block,               
                                        true);                        
  if (rc)                                                             
 2019860:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2019864:	12 80 00 06 	bne  201987c <rtems_rfs_bitmap_load_map+0x4c>  <== NEVER TAKEN
 2019868:	01 00 00 00 	nop                                            
    return rc;                                                        
                                                                      
  *map = rtems_rfs_buffer_data (control->buffer);                     
 201986c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 2019870:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 2019874:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 2019878:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  return 0;                                                           
}                                                                     
 201987c:	81 c7 e0 08 	ret                                            
 2019880:	81 e8 00 00 	restore                                        
                                                                      

02019e00 <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) {
 2019e00:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int                  rc = 0;                                        
                                                                      
  /*                                                                  
   * By default we assume the allocation failed.                      
   */                                                                 
  *allocated = false;                                                 
 2019e04:	c0 2e 80 00 	clrb  [ %i2 ]                                  
   * 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))          
 2019e08:	10 80 00 2d 	b  2019ebc <rtems_rfs_bitmap_map_alloc+0xbc>   
 2019e0c:	ba 10 00 19 	mov  %i1, %i5                                  
         || ((lower_seed >= 0) && (lower_seed < control->size)))      
  {                                                                   
    /*                                                                
     * Search up first so bits allocated in succession are grouped together.
     */                                                               
    if (upper_seed < control->size)                                   
 2019e10:	2a 80 00 07 	bcs,a   2019e2c <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
 2019e14:	fa 26 c0 00 	st  %i5, [ %i3 ]                               <== NOT EXECUTED
                                               window, 1);            
      if ((rc > 0) || *allocated)                                     
        break;                                                        
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
 2019e18:	80 a6 60 00 	cmp  %i1, 0                                    
 2019e1c:	36 80 00 17 	bge,a   2019e78 <rtems_rfs_bitmap_map_alloc+0x78>
 2019e20:	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)                                   
 2019e24:	10 80 00 10 	b  2019e64 <rtems_rfs_bitmap_map_alloc+0x64>   
 2019e28:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
     * Search up first so bits allocated in succession are grouped together.
     */                                                               
    if (upper_seed < control->size)                                   
    {                                                                 
      *bit = upper_seed;                                              
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
 2019e2c:	90 10 00 18 	mov  %i0, %o0                                  
 2019e30:	92 10 00 1b 	mov  %i3, %o1                                  
 2019e34:	94 10 00 1a 	mov  %i2, %o2                                  
 2019e38:	7f ff fe 93 	call  2019884 <rtems_rfs_search_map_for_clear_bit.constprop.1>
 2019e3c:	96 10 20 01 	mov  1, %o3                                    
                                               window, 1);            
      if ((rc > 0) || *allocated)                                     
 2019e40:	80 a2 20 00 	cmp  %o0, 0                                    
 2019e44:	34 80 00 2d 	bg,a   2019ef8 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
 2019e48:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 2019e4c:	c2 0e 80 00 	ldub  [ %i2 ], %g1                             
 2019e50:	80 a0 60 00 	cmp  %g1, 0                                    
 2019e54:	02 bf ff f2 	be  2019e1c <rtems_rfs_bitmap_map_alloc+0x1c>  
 2019e58:	80 a6 60 00 	cmp  %i1, 0                                    
    if (lower_seed >= 0)                                              
      lower_seed -= window;                                           
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2019e5c:	81 c7 e0 08 	ret                                            
 2019e60:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
    /*                                                                
     * 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)                                   
 2019e64:	80 a7 40 01 	cmp  %i5, %g1                                  
 2019e68:	2a 80 00 12 	bcs,a   2019eb0 <rtems_rfs_bitmap_map_alloc+0xb0>
 2019e6c:	ba 07 68 00 	add  %i5, 0x800, %i5                           
      upper_seed += window;                                           
    if (lower_seed >= 0)                                              
 2019e70:	10 80 00 11 	b  2019eb4 <rtems_rfs_bitmap_map_alloc+0xb4>   
 2019e74:	80 a6 60 00 	cmp  %i1, 0                                    
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
    {                                                                 
      *bit = lower_seed;                                              
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
 2019e78:	90 10 00 18 	mov  %i0, %o0                                  
 2019e7c:	92 10 00 1b 	mov  %i3, %o1                                  
 2019e80:	94 10 00 1a 	mov  %i2, %o2                                  
 2019e84:	7f ff fe 80 	call  2019884 <rtems_rfs_search_map_for_clear_bit.constprop.1>
 2019e88:	96 10 3f ff 	mov  -1, %o3                                   
                                               window, -1);           
      if ((rc > 0) || *allocated)                                     
 2019e8c:	80 a2 20 00 	cmp  %o0, 0                                    
 2019e90:	34 80 00 1a 	bg,a   2019ef8 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
 2019e94:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 2019e98:	c2 0e 80 00 	ldub  [ %i2 ], %g1                             
 2019e9c:	80 a0 60 00 	cmp  %g1, 0                                    
 2019ea0:	22 bf ff f1 	be,a   2019e64 <rtems_rfs_bitmap_map_alloc+0x64>
 2019ea4:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
    if (lower_seed >= 0)                                              
      lower_seed -= window;                                           
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2019ea8:	81 c7 e0 08 	ret                                            
 2019eac:	91 e8 20 00 	restore  %g0, 0, %o0                           
     * 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)                                   
      upper_seed += window;                                           
    if (lower_seed >= 0)                                              
 2019eb0:	80 a6 60 00 	cmp  %i1, 0                                    
 2019eb4:	36 80 00 02 	bge,a   2019ebc <rtems_rfs_bitmap_map_alloc+0xbc>
 2019eb8:	b2 06 78 00 	add  %i1, -2048, %i1                           
   * 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))          
 2019ebc:	80 a7 60 00 	cmp  %i5, 0                                    
 2019ec0:	06 80 00 07 	bl  2019edc <rtems_rfs_bitmap_map_alloc+0xdc>  
 2019ec4:	80 a6 60 00 	cmp  %i1, 0                                    
 2019ec8:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 2019ecc:	80 a7 40 01 	cmp  %i5, %g1                                  
 2019ed0:	2a bf ff d7 	bcs,a   2019e2c <rtems_rfs_bitmap_map_alloc+0x2c>
 2019ed4:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
         || ((lower_seed >= 0) && (lower_seed < control->size)))      
 2019ed8:	80 a6 60 00 	cmp  %i1, 0                                    
 2019edc:	26 80 00 07 	bl,a   2019ef8 <rtems_rfs_bitmap_map_alloc+0xf8>
 2019ee0:	b0 10 20 00 	clr  %i0                                       
 2019ee4:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 2019ee8:	80 a6 40 01 	cmp  %i1, %g1                                  
 2019eec:	0a bf ff c9 	bcs  2019e10 <rtems_rfs_bitmap_map_alloc+0x10> 
 2019ef0:	80 a7 40 01 	cmp  %i5, %g1                                  
    if (lower_seed >= 0)                                              
      lower_seed -= window;                                           
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2019ef4:	b0 10 20 00 	clr  %i0                                       
 2019ef8:	81 c7 e0 08 	ret                                            
 2019efc:	81 e8 00 00 	restore                                        
                                                                      

02019b04 <rtems_rfs_bitmap_mask>: 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); return mask; }
 2019b04:	82 10 3f ff 	mov  -1, %g1                                   <== 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);                 
 2019b08:	90 20 00 08 	neg  %o0                                       <== NOT EXECUTED
  return mask;                                                        
}                                                                     
 2019b0c:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2019b10:	91 30 40 08 	srl  %g1, %o0, %o0                             <== NOT EXECUTED
                                                                      

02019b14 <rtems_rfs_bitmap_mask_section>: rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end) {
 2019b14:	82 10 00 08 	mov  %o0, %g1                                  
  rtems_rfs_bitmap_element mask = 0;                                  
  if (end > start)                                                    
 2019b18:	80 a2 40 01 	cmp  %o1, %g1                                  
 2019b1c:	08 80 00 06 	bleu  2019b34 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
 2019b20:	90 10 20 00 	clr  %o0                                       
                                                                      
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);                 
 2019b24:	92 20 40 09 	sub  %g1, %o1, %o1                             
 2019b28:	90 10 3f ff 	mov  -1, %o0                                   
 2019b2c:	91 32 00 09 	srl  %o0, %o1, %o0                             
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;              
 2019b30:	91 2a 00 01 	sll  %o0, %g1, %o0                             
  return mask;                                                        
}                                                                     
 2019b34:	81 c3 e0 08 	retl                                           
                                                                      

0201a268 <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) {
 201a268:	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);     
 201a26c:	96 10 20 01 	mov  1, %o3                                    
 201a270:	90 10 00 18 	mov  %i0, %o0                                  
 201a274:	92 10 00 19 	mov  %i1, %o1                                  
 201a278:	40 00 04 60 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201a27c:	94 10 00 1a 	mov  %i2, %o2                                  
  if (rc > 0)                                                         
 201a280:	80 a2 20 00 	cmp  %o0, 0                                    
 201a284:	14 80 00 26 	bg  201a31c <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
 201a288:	87 2e e0 02 	sll  %i3, 2, %g3                               
    return rc;                                                        
                                                                      
  *result = rtems_rfs_block_get_number (buffer, offset);              
 201a28c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201a290:	c8 00 60 1c 	ld  [ %g1 + 0x1c ], %g4                        
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
 201a294:	90 10 20 00 	clr  %o0                                       
   */                                                                 
  rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  *result = rtems_rfs_block_get_number (buffer, offset);              
 201a298:	84 01 00 03 	add  %g4, %g3, %g2                             
 201a29c:	c2 09 00 03 	ldub  [ %g4 + %g3 ], %g1                       
 201a2a0:	fa 08 a0 03 	ldub  [ %g2 + 3 ], %i5                         
 201a2a4:	c6 08 a0 01 	ldub  [ %g2 + 1 ], %g3                         
 201a2a8:	c4 08 a0 02 	ldub  [ %g2 + 2 ], %g2                         
 201a2ac:	83 28 60 18 	sll  %g1, 0x18, %g1                            
 201a2b0:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201a2b4:	82 17 40 01 	or  %i5, %g1, %g1                              
 201a2b8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 201a2bc:	82 10 40 03 	or  %g1, %g3, %g1                              
 201a2c0:	82 10 40 02 	or  %g1, %g2, %g1                              
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
 201a2c4:	84 38 00 01 	xnor  %g0, %g1, %g2                            
 201a2c8:	80 a0 00 02 	cmp  %g0, %g2                                  
 201a2cc:	84 60 20 00 	subx  %g0, 0, %g2                              
 201a2d0:	82 08 40 02 	and  %g1, %g2, %g1                             
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
 201a2d4:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
 201a2d8:	80 a0 40 02 	cmp  %g1, %g2                                  
 201a2dc:	0a 80 00 10 	bcs  201a31c <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
 201a2e0:	c2 27 00 00 	st  %g1, [ %i4 ]                               
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))                 
 201a2e4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201a2e8:	7f ff e5 08 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201a2ec:	13 00 00 04 	sethi  %hi(0x1000), %o1                        <== NOT EXECUTED
 201a2f0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201a2f4:	22 80 00 09 	be,a   201a318 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
 201a2f8:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
      printf ("rtems-rfs: block-find: invalid block in table:"        
 201a2fc:	d2 07 00 00 	ld  [ %i4 ], %o1                               <== NOT EXECUTED
 201a300:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201a304:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 201a308:	90 12 21 20 	or  %o0, 0x120, %o0                            <== NOT EXECUTED
 201a30c:	40 00 1f 1e 	call  2021f84 <printf>                         <== NOT EXECUTED
 201a310:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
              " block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
    *result = 0;                                                      
 201a314:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
 201a318:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 201a31c:	81 c7 e0 08 	ret                                            
 201a320:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0201a388 <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) {
 201a388:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  if (pos == 0)                                                       
 201a38c:	80 96 40 1a 	orcc  %i1, %i2, %g0                            <== NOT EXECUTED
 201a390:	32 80 00 06 	bne,a   201a3a8 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
 201a394:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           <== 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;                                                    
 201a398:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
  size->offset = 0;                                                   
 201a39c:	c0 26 e0 04 	clr  [ %i3 + 4 ]                               <== NOT EXECUTED
 201a3a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201a3a4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    rtems_rfs_block_set_size_zero (size);                             
  else                                                                
  {                                                                   
    size->count  = pos / rtems_rfs_fs_block_size (fs) + 1;            
 201a3a8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201a3ac:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
 201a3b0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 201a3b4:	40 00 52 44 	call  202ecc4 <__udivdi3>                      <== NOT EXECUTED
 201a3b8:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201a3bc:	92 02 60 01 	inc  %o1                                       <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
 201a3c0:	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;            
 201a3c4:	d2 26 c0 00 	st  %o1, [ %i3 ]                               <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
 201a3c8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201a3cc:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201a3d0:	40 00 53 11 	call  202f014 <__umoddi3>                      <== NOT EXECUTED
 201a3d4:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
 201a3d8:	d2 26 e0 04 	st  %o1, [ %i3 + 4 ]                           <== NOT EXECUTED
 201a3dc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201a3e0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201a5c8 <rtems_rfs_block_map_close>: int rtems_rfs_block_map_close (rtems_rfs_file_system* fs, rtems_rfs_block_map* map) {
 201a5c8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
 201a5cc:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,                 
                           rtems_rfs_block_map*   map)                
{                                                                     
 201a5d0:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
 201a5d4:	80 a0 60 00 	cmp  %g1, 0                                    
 201a5d8:	02 80 00 61 	be  201a75c <rtems_rfs_block_map_close+0x194>  
 201a5dc:	b0 10 20 00 	clr  %i0                                       
 201a5e0:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           
 201a5e4:	80 a2 60 00 	cmp  %o1, 0                                    
 201a5e8:	22 80 00 5e 	be,a   201a760 <rtems_rfs_block_map_close+0x198><== NEVER TAKEN
 201a5ec:	92 06 60 38 	add  %i1, 0x38, %o1                            <== NOT EXECUTED
  {                                                                   
    brc = rtems_rfs_inode_load (fs, map->inode);                      
 201a5f0:	7f ff dd 90 	call  2011c30 <rtems_rfs_inode_load>           
 201a5f4:	90 10 00 1d 	mov  %i5, %o0                                  
    if (brc > 0)                                                      
 201a5f8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201a5fc:	14 80 00 59 	bg  201a760 <rtems_rfs_block_map_close+0x198>  <== NEVER TAKEN
 201a600:	92 06 60 38 	add  %i1, 0x38, %o1                            
 201a604:	82 10 20 00 	clr  %g1                                       
 */                                                                   
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);                      
 201a608:	b8 10 20 01 	mov  1, %i4                                    
    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]);    
 201a60c:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
                                                                      
  return rc;                                                          
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,                 
 201a610:	87 28 60 02 	sll  %g1, 2, %g3                               
 * @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);       
 201a614:	f6 00 a0 0c 	ld  [ %g2 + 0xc ], %i3                         
 201a618:	86 06 40 03 	add  %i1, %g3, %g3                             
    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]);    
 201a61c:	c6 00 e0 24 	ld  [ %g3 + 0x24 ], %g3                        
 201a620:	88 00 60 06 	add  %g1, 6, %g4                               
 201a624:	89 29 20 02 	sll  %g4, 2, %g4                               
 201a628:	b6 06 c0 04 	add  %i3, %g4, %i3                             
 201a62c:	b5 30 e0 18 	srl  %g3, 0x18, %i2                            
 201a630:	f4 2e e0 04 	stb  %i2, [ %i3 + 4 ]                          
 201a634:	f6 00 a0 0c 	ld  [ %g2 + 0xc ], %i3                         
 201a638:	b5 30 e0 10 	srl  %g3, 0x10, %i2                            
 201a63c:	b6 06 c0 04 	add  %i3, %g4, %i3                             
 201a640:	f4 2e e0 05 	stb  %i2, [ %i3 + 5 ]                          
 201a644:	f6 00 a0 0c 	ld  [ %g2 + 0xc ], %i3                         
 201a648:	b5 30 e0 08 	srl  %g3, 8, %i2                               
 201a64c:	b6 06 c0 04 	add  %i3, %g4, %i3                             
 201a650:	f4 2e e0 06 	stb  %i2, [ %i3 + 6 ]                          
 201a654:	f6 00 a0 0c 	ld  [ %g2 + 0xc ], %i3                         
                                                                      
    if (rc == 0)                                                      
    {                                                                 
      int b;                                                          
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
 201a658:	82 00 60 01 	inc  %g1                                       
 201a65c:	88 06 c0 04 	add  %i3, %g4, %g4                             
 201a660:	c6 29 20 07 	stb  %g3, [ %g4 + 7 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201a664:	f8 28 a0 10 	stb  %i4, [ %g2 + 0x10 ]                       
 201a668:	80 a0 60 05 	cmp  %g1, 5                                    
 201a66c:	12 bf ff e8 	bne  201a60c <rtems_rfs_block_map_close+0x44>  
 201a670:	86 10 20 01 	mov  1, %g3                                    
        rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);    
      rtems_rfs_inode_set_block_count (map->inode, map->size.count);  
 201a674:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 201a678:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
 * @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);      
 201a67c:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a680:	b9 30 a0 18 	srl  %g2, 0x18, %i4                            
 201a684:	f8 29 20 0c 	stb  %i4, [ %g4 + 0xc ]                        
 201a688:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a68c:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
 201a690:	f8 29 20 0d 	stb  %i4, [ %g4 + 0xd ]                        
 201a694:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a698:	b9 30 a0 08 	srl  %g2, 8, %i4                               
 201a69c:	f8 29 20 0e 	stb  %i4, [ %g4 + 0xe ]                        
 201a6a0:	c8 00 60 0c 	ld  [ %g1 + 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);            
 201a6a4:	90 10 00 1d 	mov  %i5, %o0                                  
 201a6a8:	c4 29 20 0f 	stb  %g2, [ %g4 + 0xf ]                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201a6ac:	c6 28 60 10 	stb  %g3, [ %g1 + 0x10 ]                       
      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);
 201a6b0:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 */                                                                   
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);    
 201a6b4:	f8 0e 60 0e 	ldub  [ %i1 + 0xe ], %i4                       
 201a6b8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
 201a6bc:	c8 06 60 0c 	ld  [ %i1 + 0xc ], %g4                         
 201a6c0:	f8 28 a0 0a 	stb  %i4, [ %g2 + 0xa ]                        
 201a6c4:	c4 00 60 0c 	ld  [ %g1 + 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);            
 201a6c8:	94 10 20 01 	mov  1, %o2                                    
 201a6cc:	c8 28 a0 0b 	stb  %g4, [ %g2 + 0xb ]                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201a6d0:	c6 28 60 10 	stb  %g3, [ %g1 + 0x10 ]                       
                                                                      
      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);
 201a6d4:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 201a6d8:	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);
 201a6dc:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a6e0:	b9 30 a0 18 	srl  %g2, 0x18, %i4                            
 201a6e4:	f8 29 20 30 	stb  %i4, [ %g4 + 0x30 ]                       
 201a6e8:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a6ec:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
 201a6f0:	f8 29 20 31 	stb  %i4, [ %g4 + 0x31 ]                       
 201a6f4:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a6f8:	b9 30 a0 08 	srl  %g2, 8, %i4                               
 201a6fc:	f8 29 20 32 	stb  %i4, [ %g4 + 0x32 ]                       
 201a700:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a704:	c4 29 20 33 	stb  %g2, [ %g4 + 0x33 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201a708:	c6 28 60 10 	stb  %g3, [ %g1 + 0x10 ]                       
      rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
 201a70c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 201a710:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
 * @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);
 201a714:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a718:	b9 30 a0 18 	srl  %g2, 0x18, %i4                            
 201a71c:	f8 29 20 34 	stb  %i4, [ %g4 + 0x34 ]                       
 201a720:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a724:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
 201a728:	f8 29 20 35 	stb  %i4, [ %g4 + 0x35 ]                       
 201a72c:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a730:	b9 30 a0 08 	srl  %g2, 8, %i4                               
 201a734:	f8 29 20 36 	stb  %i4, [ %g4 + 0x36 ]                       
 201a738:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
 201a73c:	c4 29 20 37 	stb  %g2, [ %g4 + 0x37 ]                       
                                                                      
      brc = rtems_rfs_inode_unload (fs, map->inode, true);            
 201a740:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           
 201a744:	7f ff dd 9e 	call  2011dbc <rtems_rfs_inode_unload>         
 201a748:	c6 28 60 10 	stb  %g3, [ %g1 + 0x10 ]                       
      if (brc > 0)                                                    
        rc = brc;                                                     
                                                                      
      map->dirty = false;                                             
 201a74c:	c0 2e 40 00 	clrb  [ %i1 ]                                  
 201a750:	82 38 00 08 	xnor  %g0, %o0, %g1                            
 201a754:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
 201a758:	b0 0a 00 01 	and  %o0, %g1, %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);                       
 201a75c:	92 06 60 38 	add  %i1, 0x38, %o1                            
    }                                                                 
  }                                                                   
                                                                      
  map->inode = NULL;                                                  
 201a760:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
 201a764:	40 00 02 b1 	call  201b228 <rtems_rfs_buffer_handle_release>
 201a768:	90 10 00 1d 	mov  %i5, %o0                                  
 201a76c:	90 10 00 1d 	mov  %i5, %o0                                  
  handle->dirty = false;                                              
 201a770:	c0 2e 60 38 	clrb  [ %i1 + 0x38 ]                           
  handle->bnum  = 0;                                                  
 201a774:	c0 26 60 3c 	clr  [ %i1 + 0x3c ]                            
  handle->buffer = NULL;                                              
 201a778:	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);                       
 201a77c:	40 00 02 ab 	call  201b228 <rtems_rfs_buffer_handle_release>
 201a780:	92 06 60 44 	add  %i1, 0x44, %o1                            
  handle->dirty = false;                                              
 201a784:	c0 2e 60 44 	clrb  [ %i1 + 0x44 ]                           
  handle->bnum  = 0;                                                  
 201a788:	c0 26 60 48 	clr  [ %i1 + 0x48 ]                            
  handle->buffer = NULL;                                              
 201a78c:	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;                                                          
}                                                                     
 201a790:	81 c7 e0 08 	ret                                            
 201a794:	81 e8 00 00 	restore                                        
                                                                      

0201a798 <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) {
 201a798:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int rc = 0;                                                         
                                                                      
  *block = 0;                                                         
 201a79c:	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))          
 201a7a0:	fa 06 80 00 	ld  [ %i2 ], %i5                               
 201a7a4:	80 a7 60 00 	cmp  %i5, 0                                    
 201a7a8:	02 80 00 05 	be  201a7bc <rtems_rfs_block_map_find+0x24>    
 201a7ac:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
 201a7b0:	80 a7 20 00 	cmp  %i4, 0                                    
 201a7b4:	02 80 00 53 	be  201a900 <rtems_rfs_block_map_find+0x168>   <== NEVER TAKEN
 201a7b8:	90 10 20 06 	mov  6, %o0                                    
 201a7bc:	80 a7 40 1c 	cmp  %i5, %i4                                  
 201a7c0:	1a 80 00 50 	bcc  201a900 <rtems_rfs_block_map_find+0x168>  
 201a7c4:	90 10 20 06 	mov  6, %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))         
 201a7c8:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
 201a7cc:	80 a7 40 01 	cmp  %i5, %g1                                  
 201a7d0:	12 80 00 08 	bne  201a7f0 <rtems_rfs_block_map_find+0x58>   
 201a7d4:	80 a7 20 05 	cmp  %i4, 5                                    
 201a7d8:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
 201a7dc:	80 a0 60 00 	cmp  %g1, 0                                    
 201a7e0:	02 80 00 04 	be  201a7f0 <rtems_rfs_block_map_find+0x58>    
 201a7e4:	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];                                
 201a7e8:	10 80 00 3d 	b  201a8dc <rtems_rfs_block_map_find+0x144>    
 201a7ec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    /*                                                                
     * 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)                    
 201a7f0:	38 80 00 08 	bgu,a   201a810 <rtems_rfs_block_map_find+0x78>
 201a7f4:	e0 06 20 34 	ld  [ %i0 + 0x34 ], %l0                        
    {                                                                 
      *block = map->blocks[bpos->bno];                                
 201a7f8:	ba 07 60 08 	add  %i5, 8, %i5                               
 201a7fc:	bb 2f 60 02 	sll  %i5, 2, %i5                               
 201a800:	ba 06 40 1d 	add  %i1, %i5, %i5                             
 201a804:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 201a808:	10 80 00 35 	b  201a8dc <rtems_rfs_block_map_find+0x144>    
 201a80c:	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;                      
 201a810:	90 10 00 1d 	mov  %i5, %o0                                  
 201a814:	40 00 4e 5d 	call  202e188 <.urem>                          
 201a818:	92 10 00 10 	mov  %l0, %o1                                  
      singly = bpos->bno / fs->blocks_per_block;                      
 201a81c:	92 10 00 10 	mov  %l0, %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;                      
 201a820:	a2 10 00 08 	mov  %o0, %l1                                  
      singly = bpos->bno / fs->blocks_per_block;                      
 201a824:	7f ff 9f 96 	call  200267c <.udiv>                          
 201a828:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
 201a82c:	c2 06 20 38 	ld  [ %i0 + 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;                      
 201a830:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
 201a834:	80 a7 00 01 	cmp  %i4, %g1                                  
 201a838:	18 80 00 09 	bgu  201a85c <rtems_rfs_block_map_find+0xc4>   <== NEVER TAKEN
 201a83c:	ba 10 00 08 	mov  %o0, %i5                                  
      {                                                               
        /*                                                            
         * This is a single indirect table of blocks anchored off a slot in the
         * inode.                                                     
         */                                                           
        rc = rtems_rfs_block_find_indirect (fs,                       
 201a840:	ba 02 20 08 	add  %o0, 8, %i5                               
 201a844:	92 06 60 38 	add  %i1, 0x38, %o1                            
 201a848:	bb 2f 60 02 	sll  %i5, 2, %i5                               
 201a84c:	90 10 00 18 	mov  %i0, %o0                                  
 201a850:	ba 06 40 1d 	add  %i1, %i5, %i5                             
 201a854:	10 80 00 1c 	b  201a8c4 <rtems_rfs_block_map_find+0x12c>    
 201a858:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
 201a85c:	40 00 4e 4b 	call  202e188 <.urem>                          <== NOT EXECUTED
 201a860:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
 201a864:	c4 06 20 3c 	ld  [ %i0 + 0x3c ], %g2                        <== NOT EXECUTED
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
        singly %= fs->blocks_per_block;                               
 201a868:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          <== NOT EXECUTED
 201a86c:	a4 10 00 08 	mov  %o0, %l2                                  <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
 201a870:	80 a7 00 02 	cmp  %i4, %g2                                  <== NOT EXECUTED
 201a874:	1a 80 00 23 	bcc  201a900 <rtems_rfs_block_map_find+0x168>  <== NOT EXECUTED
 201a878:	90 10 20 06 	mov  6, %o0                                    <== NOT EXECUTED
        /*                                                            
         * The map is doubly indirect.                                
         */                                                           
        rtems_rfs_block_no doubly;                                    
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
 201a87c:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 201a880:	7f ff 9f 7f 	call  200267c <.udiv>                          <== NOT EXECUTED
 201a884:	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,                     
 201a888:	90 02 20 08 	add  %o0, 8, %o0                               <== NOT EXECUTED
 201a88c:	83 2a 20 02 	sll  %o0, 2, %g1                               <== NOT EXECUTED
 201a890:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
 201a894:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           <== NOT EXECUTED
 201a898:	b8 06 60 44 	add  %i1, 0x44, %i4                            <== NOT EXECUTED
 201a89c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201a8a0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201a8a4:	96 10 00 12 	mov  %l2, %o3                                  <== NOT EXECUTED
 201a8a8:	7f ff fe 70 	call  201a268 <rtems_rfs_block_find_indirect>  <== NOT EXECUTED
 201a8ac:	98 07 bf fc 	add  %fp, -4, %o4                              <== NOT EXECUTED
                                              &map->doubly_buffer,    
                                              map->blocks[doubly],    
                                              singly, &singly);       
          if (rc == 0)                                                
 201a8b0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201a8b4:	12 80 00 13 	bne  201a900 <rtems_rfs_block_map_find+0x168>  <== NOT EXECUTED
 201a8b8:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
          {                                                           
            rc = rtems_rfs_block_find_indirect (fs,                   
 201a8bc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201a8c0:	92 06 60 38 	add  %i1, 0x38, %o1                            <== NOT EXECUTED
 201a8c4:	96 10 00 11 	mov  %l1, %o3                                  
 201a8c8:	7f ff fe 68 	call  201a268 <rtems_rfs_block_find_indirect>  
 201a8cc:	98 10 00 1b 	mov  %i3, %o4                                  
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
 201a8d0:	80 a2 20 00 	cmp  %o0, 0                                    
 201a8d4:	12 80 00 0b 	bne  201a900 <rtems_rfs_block_map_find+0x168>  <== NEVER TAKEN
 201a8d8:	01 00 00 00 	nop                                            
  {                                                                   
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
 201a8dc:	c2 06 80 00 	ld  [ %i2 ], %g1                               
    map->bpos.block = *block;                                         
 201a8e0:	90 10 20 00 	clr  %o0                                       
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
  {                                                                   
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
 201a8e4:	c2 26 60 10 	st  %g1, [ %i1 + 0x10 ]                        
 201a8e8:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
 201a8ec:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        
 201a8f0:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
 201a8f4:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        
    map->bpos.block = *block;                                         
 201a8f8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 201a8fc:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 201a900:	81 c7 e0 08 	ret                                            
 201a904:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0201a9b0 <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) {
 201a9b0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int b;                                                              
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
 201a9b4:	90 10 20 00 	clr  %o0                                       
 201a9b8:	13 00 00 08 	sethi  %hi(0x2000), %o1                        
 201a9bc:	7f ff e3 53 	call  2013708 <rtems_rfs_trace>                
 201a9c0:	ba 10 00 18 	mov  %i0, %i5                                  
 201a9c4:	80 8a 20 ff 	btst  0xff, %o0                                
 201a9c8:	22 80 00 08 	be,a   201a9e8 <rtems_rfs_block_map_grow+0x38> <== ALWAYS TAKEN
 201a9cc:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
    printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
 201a9d0:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           <== NOT EXECUTED
 201a9d4:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201a9d8:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201a9dc:	40 00 1d 6a 	call  2021f84 <printf>                         <== NOT EXECUTED
 201a9e0:	90 12 21 70 	or  %o0, 0x170, %o0                            <== NOT EXECUTED
            blocks, map->size.count);                                 
                                                                      
  if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
 201a9e4:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
 201a9e8:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
 201a9ec:	84 06 80 02 	add  %i2, %g2, %g2                             
 201a9f0:	80 a0 80 01 	cmp  %g2, %g1                                  
 201a9f4:	1a 80 00 b2 	bcc  201acbc <rtems_rfs_block_map_grow+0x30c>  <== NEVER TAKEN
 201a9f8:	b0 10 20 1b 	mov  0x1b, %i0                                 
  map->last_map_block = new_block;                                    
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,                  
 201a9fc:	10 80 00 d4 	b  201ad4c <rtems_rfs_block_map_grow+0x39c>    
 201aa00:	a0 10 20 00 	clr  %l0                                       
    /*                                                                
     * 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,      
 201aa04:	90 10 00 1d 	mov  %i5, %o0                                  
 201aa08:	94 10 20 00 	clr  %o2                                       
 201aa0c:	7f ff db 61 	call  2011790 <rtems_rfs_group_bitmap_alloc>   
 201aa10:	96 07 bf f8 	add  %fp, -8, %o3                              
                                       false, &block);                
    if (rc > 0)                                                       
 201aa14:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201aa18:	14 80 00 d4 	bg  201ad68 <rtems_rfs_block_map_grow+0x3b8>   
 201aa1c:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    if (map->size.count < RTEMS_RFS_INODE_BLOCKS)                     
 201aa20:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
 201aa24:	80 a7 20 04 	cmp  %i4, 4                                    
 201aa28:	38 80 00 08 	bgu,a   201aa48 <rtems_rfs_block_map_grow+0x98>
 201aa2c:	f0 07 60 34 	ld  [ %i5 + 0x34 ], %i0                        
      map->blocks[map->size.count] = block;                           
 201aa30:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 201aa34:	b8 07 20 08 	add  %i4, 8, %i4                               
 201aa38:	b9 2f 20 02 	sll  %i4, 2, %i4                               
 201aa3c:	b8 06 40 1c 	add  %i1, %i4, %i4                             
 201aa40:	10 80 00 b7 	b  201ad1c <rtems_rfs_block_map_grow+0x36c>    
 201aa44:	c2 27 20 04 	st  %g1, [ %i4 + 4 ]                           
       * 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;                
 201aa48:	90 10 00 1c 	mov  %i4, %o0                                  
 201aa4c:	40 00 4d cf 	call  202e188 <.urem>                          
 201aa50:	92 10 00 18 	mov  %i0, %o1                                  
      singly = map->size.count / fs->blocks_per_block;                
 201aa54:	92 10 00 18 	mov  %i0, %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;                
 201aa58:	a4 10 00 08 	mov  %o0, %l2                                  
      singly = map->size.count / fs->blocks_per_block;                
 201aa5c:	7f ff 9f 08 	call  200267c <.udiv>                          
 201aa60:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
      if (map->size.count < fs->block_map_singly_blocks)              
 201aa64:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
 201aa68:	80 a7 00 01 	cmp  %i4, %g1                                  
 201aa6c:	1a 80 00 1d 	bcc  201aae0 <rtems_rfs_block_map_grow+0x130>  <== NEVER TAKEN
 201aa70:	ac 10 00 08 	mov  %o0, %l6                                  
         * 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) ||                                          
 201aa74:	80 a4 a0 00 	cmp  %l2, 0                                    
 201aa78:	22 80 00 07 	be,a   201aa94 <rtems_rfs_block_map_grow+0xe4> <== NEVER TAKEN
 201aa7c:	b8 1f 20 05 	xor  %i4, 5, %i4                               <== NOT EXECUTED
 201aa80:	80 a4 a0 05 	cmp  %l2, 5                                    
 201aa84:	12 80 00 10 	bne  201aac4 <rtems_rfs_block_map_grow+0x114>  
 201aa88:	80 a2 20 00 	cmp  %o0, 0                                    
 201aa8c:	12 80 00 0e 	bne  201aac4 <rtems_rfs_block_map_grow+0x114>  <== NEVER TAKEN
 201aa90:	b8 1f 20 05 	xor  %i4, 5, %i4                               
          /*                                                          
           * 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,           
 201aa94:	80 a0 00 1c 	cmp  %g0, %i4                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
 201aa98:	96 05 a0 08 	add  %l6, 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,           
 201aa9c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
 201aaa0:	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,           
 201aaa4:	92 10 00 19 	mov  %i1, %o1                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
 201aaa8:	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,           
 201aaac:	94 10 00 11 	mov  %l1, %o2                                  
 201aab0:	96 02 e0 04 	add  %o3, 4, %o3                               
 201aab4:	7f ff fd 9c 	call  201a124 <rtems_rfs_block_map_indirect_alloc>
 201aab8:	98 60 3f ff 	subx  %g0, -1, %o4                             
          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)                                                 
 201aabc:	10 80 00 7a 	b  201aca4 <rtems_rfs_block_map_grow+0x2f4>    
 201aac0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
                                                   &map->blocks[singly],
                                                   upping);           
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,  &map->singly_buffer,
 201aac4:	ac 05 a0 08 	add  %l6, 8, %l6                               
 201aac8:	90 10 00 1d 	mov  %i5, %o0                                  
 201aacc:	ad 2d a0 02 	sll  %l6, 2, %l6                               
 201aad0:	92 10 00 11 	mov  %l1, %o1                                  
 201aad4:	ac 06 40 16 	add  %i1, %l6, %l6                             
 201aad8:	10 80 00 70 	b  201ac98 <rtems_rfs_block_map_grow+0x2e8>    
 201aadc:	d4 05 a0 04 	ld  [ %l6 + 4 ], %o2                           
         * Doubly indirect tables are being used.                     
         */                                                           
        rtems_rfs_block_no doubly;                                    
        rtems_rfs_block_no singly_block;                              
                                                                      
        doubly  = singly / fs->blocks_per_block;                      
 201aae0:	7f ff 9e e7 	call  200267c <.udiv>                          <== NOT EXECUTED
 201aae4:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
 201aae8:	92 10 00 18 	mov  %i0, %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;                      
 201aaec:	a6 10 00 08 	mov  %o0, %l3                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
 201aaf0:	40 00 4d a6 	call  202e188 <.urem>                          <== NOT EXECUTED
 201aaf4:	90 10 00 16 	mov  %l6, %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)                                              
 201aaf8:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
 201aafc:	12 80 00 4a 	bne  201ac24 <rtems_rfs_block_map_grow+0x274>  <== NOT EXECUTED
 201ab00:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
 201ab04:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ab08:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201ab0c:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
 201ab10:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
 201ab14:	7f ff fd 84 	call  201a124 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
 201ab18:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
                                                   &map->singly_buffer,
                                                   &singly_block,     
                                                   false);            
          if (rc > 0)                                                 
 201ab1c:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 201ab20:	04 80 00 04 	ble  201ab30 <rtems_rfs_block_map_grow+0x180>  <== NOT EXECUTED
 201ab24:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                                singly_block, true);  
          if (rc > 0)                                                 
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
 201ab28:	10 80 00 62 	b  201acb0 <rtems_rfs_block_map_grow+0x300>    <== NOT EXECUTED
 201ab2c:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== 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) ||                                        
 201ab30:	22 80 00 08 	be,a   201ab50 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
 201ab34:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
 201ab38:	80 a7 20 05 	cmp  %i4, 5                                    <== NOT EXECUTED
 201ab3c:	12 80 00 13 	bne  201ab88 <rtems_rfs_block_map_grow+0x1d8>  <== NOT EXECUTED
 201ab40:	80 a4 e0 00 	cmp  %l3, 0                                    <== NOT EXECUTED
 201ab44:	32 80 00 12 	bne,a   201ab8c <rtems_rfs_block_map_grow+0x1dc><== NOT EXECUTED
 201ab48:	a6 04 e0 08 	add  %l3, 8, %l3                               <== NOT EXECUTED
              ((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))  
          {                                                           
            bool upping;                                              
            upping = map->size.count == fs->block_map_singly_blocks;  
 201ab4c:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
 201ab50:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        <== NOT EXECUTED
            rc = rtems_rfs_block_map_indirect_alloc (fs, map,         
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
 201ab54:	96 04 e0 08 	add  %l3, 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;  
 201ab58:	82 18 80 01 	xor  %g2, %g1, %g1                             <== NOT EXECUTED
            rc = rtems_rfs_block_map_indirect_alloc (fs, map,         
 201ab5c:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
 201ab60:	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,         
 201ab64:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
 201ab68:	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,         
 201ab6c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201ab70:	94 10 00 15 	mov  %l5, %o2                                  <== NOT EXECUTED
 201ab74:	96 02 e0 04 	add  %o3, 4, %o3                               <== NOT EXECUTED
 201ab78:	7f ff fd 6b 	call  201a124 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
 201ab7c:	98 60 3f ff 	subx  %g0, -1, %o4                             <== NOT EXECUTED
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
                                                  map->blocks[doubly], true);
            if (rc > 0)                                               
 201ab80:	10 80 00 0b 	b  201abac <rtems_rfs_block_map_grow+0x1fc>    <== NOT EXECUTED
 201ab84:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
 201ab88:	a6 04 e0 08 	add  %l3, 8, %l3                               <== NOT EXECUTED
 201ab8c:	a7 2c e0 02 	sll  %l3, 2, %l3                               <== NOT EXECUTED
 201ab90:	a6 06 40 13 	add  %i1, %l3, %l3                             <== NOT EXECUTED
 201ab94:	d4 04 e0 04 	ld  [ %l3 + 4 ], %o2                           <== NOT EXECUTED
 201ab98:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ab9c:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
 201aba0:	40 00 02 16 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201aba4:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                                  map->blocks[doubly], true);
            if (rc > 0)                                               
 201aba8:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 201abac:	24 80 00 08 	ble,a   201abcc <rtems_rfs_block_map_grow+0x21c><== NOT EXECUTED
 201abb0:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
            {                                                         
              rtems_rfs_group_bitmap_free (fs, false, singly_block);  
 201abb4:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
 201abb8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201abbc:	7f ff db 79 	call  20119a0 <rtems_rfs_group_bitmap_free>    <== NOT EXECUTED
 201abc0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                                singly_block, true);  
          if (rc > 0)                                                 
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
 201abc4:	10 80 00 3b 	b  201acb0 <rtems_rfs_block_map_grow+0x300>    <== NOT EXECUTED
 201abc8:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
              rtems_rfs_group_bitmap_free (fs, false, block);         
              return rc;                                              
            }                                                         
          }                                                           
                                                                      
          rtems_rfs_block_set_number (&map->doubly_buffer,            
 201abcc:	c4 0f bf fc 	ldub  [ %fp + -4 ], %g2                        <== NOT EXECUTED
 201abd0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
 201abd4:	b9 2f 20 02 	sll  %i4, 2, %i4                               <== NOT EXECUTED
 201abd8:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        <== NOT EXECUTED
 201abdc:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
 201abe0:	c4 17 bf fc 	lduh  [ %fp + -4 ], %g2                        <== NOT EXECUTED
 201abe4:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
 201abe8:	82 00 40 1c 	add  %g1, %i4, %g1                             <== NOT EXECUTED
 201abec:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          <== NOT EXECUTED
 201abf0:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
 201abf4:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== NOT EXECUTED
 201abf8:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
 201abfc:	85 30 a0 08 	srl  %g2, 8, %g2                               <== NOT EXECUTED
 201ac00:	82 00 40 1c 	add  %g1, %i4, %g1                             <== NOT EXECUTED
 201ac04:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          <== NOT EXECUTED
 201ac08:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
 201ac0c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
 201ac10:	b8 00 40 1c 	add  %g1, %i4, %i4                             <== NOT EXECUTED
 201ac14:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
 201ac18:	c2 2f 20 03 	stb  %g1, [ %i4 + 3 ]                          <== NOT EXECUTED
 201ac1c:	10 80 00 2a 	b  201acc4 <rtems_rfs_block_map_grow+0x314>    <== NOT EXECUTED
 201ac20:	e8 2e 60 44 	stb  %l4, [ %i1 + 0x44 ]                       <== NOT EXECUTED
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
 201ac24:	a6 04 e0 08 	add  %l3, 8, %l3                               <== NOT EXECUTED
 201ac28:	a7 2c e0 02 	sll  %l3, 2, %l3                               <== NOT EXECUTED
 201ac2c:	a6 06 40 13 	add  %i1, %l3, %l3                             <== NOT EXECUTED
 201ac30:	d4 04 e0 04 	ld  [ %l3 + 4 ], %o2                           <== NOT EXECUTED
 201ac34:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ac38:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
 201ac3c:	40 00 01 ef 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201ac40:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                                &map->doubly_buffer,  
                                                map->blocks[doubly],  
                                                true);                
          if (rc > 0)                                                 
 201ac44:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 201ac48:	24 80 00 04 	ble,a   201ac58 <rtems_rfs_block_map_grow+0x2a8><== NOT EXECUTED
 201ac4c:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
                                                singly_block, true);  
          if (rc > 0)                                                 
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
 201ac50:	10 80 00 18 	b  201acb0 <rtems_rfs_block_map_grow+0x300>    <== NOT EXECUTED
 201ac54:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
 201ac58:	b9 2f 20 02 	sll  %i4, 2, %i4                               <== NOT EXECUTED
 201ac5c:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201ac60:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
 201ac64:	82 00 80 1c 	add  %g2, %i4, %g1                             <== NOT EXECUTED
 201ac68:	d4 08 80 1c 	ldub  [ %g2 + %i4 ], %o2                       <== NOT EXECUTED
 201ac6c:	c6 08 60 03 	ldub  [ %g1 + 3 ], %g3                         <== NOT EXECUTED
 201ac70:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
 201ac74:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
 201ac78:	95 2a a0 18 	sll  %o2, 0x18, %o2                            <== NOT EXECUTED
 201ac7c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
 201ac80:	94 10 c0 0a 	or  %g3, %o2, %o2                              <== NOT EXECUTED
 201ac84:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
 201ac88:	94 12 80 02 	or  %o2, %g2, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201ac8c:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
            return rc;                                                
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
 201ac90:	94 12 80 01 	or  %o2, %g1, %o2                              <== NOT EXECUTED
 201ac94:	d4 27 bf fc 	st  %o2, [ %fp + -4 ]                          <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201ac98:	40 00 01 d8 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201ac9c:	96 10 20 01 	mov  1, %o3                                    
                                                singly_block, true);  
          if (rc > 0)                                                 
 201aca0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201aca4:	24 80 00 09 	ble,a   201acc8 <rtems_rfs_block_map_grow+0x318><== ALWAYS TAKEN
 201aca8:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
          {                                                           
            rtems_rfs_group_bitmap_free (fs, false, block);           
 201acac:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
 201acb0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201acb4:	7f ff db 3b 	call  20119a0 <rtems_rfs_group_bitmap_free>    <== NOT EXECUTED
 201acb8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201acbc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201acc0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
            return rc;                                                
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
 201acc4:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        <== NOT EXECUTED
 201acc8:	c4 0f bf f8 	ldub  [ %fp + -8 ], %g2                        
 201accc:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 201acd0:	a5 2c a0 02 	sll  %l2, 2, %l2                               
 201acd4:	c4 28 40 12 	stb  %g2, [ %g1 + %l2 ]                        
 201acd8:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
 201acdc:	c4 17 bf f8 	lduh  [ %fp + -8 ], %g2                        
 201ace0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 201ace4:	82 00 40 12 	add  %g1, %l2, %g1                             
 201ace8:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
 201acec:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
 201acf0:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
 201acf4:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 201acf8:	85 30 a0 08 	srl  %g2, 8, %g2                               
 201acfc:	82 00 40 12 	add  %g1, %l2, %g1                             
 201ad00:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
 201ad04:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
 201ad08:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 201ad0c:	a4 00 40 12 	add  %g1, %l2, %l2                             
 201ad10:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 201ad14:	c2 2c a0 03 	stb  %g1, [ %l2 + 3 ]                          
 201ad18:	e8 2e 60 38 	stb  %l4, [ %i1 + 0x38 ]                       
    }                                                                 
                                                                      
    map->size.count++;                                                
 201ad1c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    map->size.offset = 0;                                             
 201ad20:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
    }                                                                 
                                                                      
    map->size.count++;                                                
 201ad24:	82 00 60 01 	inc  %g1                                       
 201ad28:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
    map->size.offset = 0;                                             
                                                                      
    if (b == 0)                                                       
 201ad2c:	80 a4 20 00 	cmp  %l0, 0                                    
 201ad30:	12 80 00 03 	bne  201ad3c <rtems_rfs_block_map_grow+0x38c>  <== NEVER TAKEN
 201ad34:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
      *new_block = block;                                             
 201ad38:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    map->last_data_block = block;                                     
 201ad3c:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        
    map->dirty = true;                                                
 201ad40:	e8 2e 40 00 	stb  %l4, [ %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++)                                        
 201ad44:	10 80 00 05 	b  201ad58 <rtems_rfs_block_map_grow+0x3a8>    
 201ad48:	a0 04 20 01 	inc  %l0                                       
            return rc;                                                
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
 201ad4c:	a8 10 20 01 	mov  1, %l4                                    
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
 201ad50:	aa 06 60 44 	add  %i1, 0x44, %l5                            
          }                                                           
                                                                      
          singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201ad54:	a2 06 60 38 	add  %i1, 0x38, %l1                            
                                                                      
  /*                                                                  
   * 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++)                                        
 201ad58:	80 a4 00 1a 	cmp  %l0, %i2                                  
 201ad5c:	32 bf ff 2a 	bne,a   201aa04 <rtems_rfs_block_map_grow+0x54>
 201ad60:	d2 06 60 20 	ld  [ %i1 + 0x20 ], %o1                        
      *new_block = block;                                             
    map->last_data_block = block;                                     
    map->dirty = true;                                                
  }                                                                   
                                                                      
  return 0;                                                           
 201ad64:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 201ad68:	81 c7 e0 08 	ret                                            
 201ad6c:	81 e8 00 00 	restore                                        
                                                                      

0201a124 <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) {
 201a124:	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);
 201a128:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
 201a12c:	90 10 00 18 	mov  %i0, %o0                                  
 201a130:	94 10 20 00 	clr  %o2                                       
 201a134:	7f ff dd 97 	call  2011790 <rtems_rfs_group_bitmap_alloc>   
 201a138:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (rc > 0)                                                         
 201a13c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201a140:	34 80 00 48 	bg,a   201a260 <rtems_rfs_block_map_indirect_alloc+0x13c><== NEVER TAKEN
 201a144:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
    return rc;                                                        
  rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
 201a148:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
 201a14c:	90 10 00 18 	mov  %i0, %o0                                  
 201a150:	92 10 00 1a 	mov  %i2, %o1                                  
 201a154:	40 00 04 a9 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201a158:	96 10 20 00 	clr  %o3                                       
  if (rc > 0)                                                         
 201a15c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201a160:	04 80 00 07 	ble  201a17c <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
 201a164:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
  {                                                                   
    rtems_rfs_group_bitmap_free (fs, false, new_block);               
 201a168:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201a16c:	7f ff de 0d 	call  20119a0 <rtems_rfs_group_bitmap_free>    <== NOT EXECUTED
 201a170:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
  *block = new_block;                                                 
  map->last_map_block = new_block;                                    
  return 0;                                                           
}                                                                     
 201a174:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201a178:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== 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));
 201a17c:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
 201a180:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           
 201a184:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 201a188:	40 00 1f 01 	call  2021d8c <memset>                         
 201a18c:	92 10 20 ff 	mov  0xff, %o1                                 
  if (upping)                                                         
 201a190:	80 a7 20 00 	cmp  %i4, 0                                    
 201a194:	02 80 00 2d 	be  201a248 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
 201a198:	82 10 20 01 	mov  1, %g1                                    
  {                                                                   
    int b;                                                            
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))             
 201a19c:	90 10 20 00 	clr  %o0                                       
 201a1a0:	7f ff e5 5a 	call  2013708 <rtems_rfs_trace>                
 201a1a4:	13 00 00 08 	sethi  %hi(0x2000), %o1                        
 201a1a8:	80 8a 20 ff 	btst  0xff, %o0                                
 201a1ac:	02 80 00 07 	be  201a1c8 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
 201a1b0:	84 10 00 19 	mov  %i1, %g2                                  
      printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
 201a1b4:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201a1b8:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201a1bc:	40 00 1f 72 	call  2021f84 <printf>                         <== NOT EXECUTED
 201a1c0:	90 12 20 e8 	or  %o0, 0xe8, %o0	! 20334e8 <CSWTCH.2+0x8>    <== NOT EXECUTED
 201a1c4:	84 10 00 19 	mov  %i1, %g2                                  <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system*   fs,      
                                    rtems_rfs_block_map*     map,     
                                    rtems_rfs_buffer_handle* buffer,  
                                    rtems_rfs_block_no*      block,   
                                    bool                     upping)  
{                                                                     
 201a1c8:	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]);         
 201a1cc:	86 10 20 01 	mov  1, %g3                                    
 201a1d0:	c8 06 a0 08 	ld  [ %i2 + 8 ], %g4                           
 201a1d4:	fa 08 a0 24 	ldub  [ %g2 + 0x24 ], %i5                      
 201a1d8:	c8 01 20 1c 	ld  [ %g4 + 0x1c ], %g4                        
 201a1dc:	fa 29 00 01 	stb  %i5, [ %g4 + %g1 ]                        
 201a1e0:	c8 06 a0 08 	ld  [ %i2 + 8 ], %g4                           
 201a1e4:	fa 10 a0 24 	lduh  [ %g2 + 0x24 ], %i5                      
 201a1e8:	c8 01 20 1c 	ld  [ %g4 + 0x1c ], %g4                        
 201a1ec:	88 01 00 01 	add  %g4, %g1, %g4                             
 201a1f0:	fa 29 20 01 	stb  %i5, [ %g4 + 1 ]                          
 201a1f4:	c8 06 a0 08 	ld  [ %i2 + 8 ], %g4                           
 201a1f8:	fa 00 a0 24 	ld  [ %g2 + 0x24 ], %i5                        
 201a1fc:	c8 01 20 1c 	ld  [ %g4 + 0x1c ], %g4                        
 201a200:	bb 37 60 08 	srl  %i5, 8, %i5                               
 201a204:	88 01 00 01 	add  %g4, %g1, %g4                             
 201a208:	fa 29 20 02 	stb  %i5, [ %g4 + 2 ]                          
 201a20c:	c8 06 a0 08 	ld  [ %i2 + 8 ], %g4                           
 201a210:	fa 00 a0 24 	ld  [ %g2 + 0x24 ], %i5                        
 201a214:	c8 01 20 1c 	ld  [ %g4 + 0x1c ], %g4                        
 201a218:	84 00 a0 04 	add  %g2, 4, %g2                               
 201a21c:	88 01 00 01 	add  %g4, %g1, %g4                             
 201a220:	fa 29 20 03 	stb  %i5, [ %g4 + 3 ]                          
 201a224:	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++)                      
 201a228:	80 a0 60 14 	cmp  %g1, 0x14                                 
 201a22c:	12 bf ff e9 	bne  201a1d0 <rtems_rfs_block_map_indirect_alloc+0xac>
 201a230:	c6 2e 80 00 	stb  %g3, [ %i2 ]                              
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
    memset (map->blocks, 0, sizeof (map->blocks));                    
 201a234:	90 06 60 24 	add  %i1, 0x24, %o0                            
 201a238:	92 10 20 00 	clr  %o1                                       
 201a23c:	40 00 1e d4 	call  2021d8c <memset>                         
 201a240:	94 10 20 14 	mov  0x14, %o2                                 
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
 201a244:	82 10 20 01 	mov  1, %g1                                    
 201a248:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
  *block = new_block;                                                 
 201a24c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  map->last_map_block = new_block;                                    
  return 0;                                                           
 201a250:	ba 10 20 00 	clr  %i5                                       
    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);                               
  *block = new_block;                                                 
 201a254:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
  map->last_map_block = new_block;                                    
 201a258:	c2 26 60 1c 	st  %g1, [ %i1 + 0x1c ]                        
  return 0;                                                           
}                                                                     
 201a25c:	b0 10 00 1d 	mov  %i5, %i0                                  
 201a260:	81 c7 e0 08 	ret                                            
 201a264:	81 e8 00 00 	restore                                        
                                                                      

0201a044 <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) {
 201a044:	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) ||                                                 
 201a048:	80 a7 20 00 	cmp  %i4, 0                                    
 201a04c:	02 80 00 09 	be  201a070 <rtems_rfs_block_map_indirect_shrink+0x2c><== NEVER TAKEN
 201a050:	82 06 e0 08 	add  %i3, 8, %g1                               
 201a054:	80 a7 20 05 	cmp  %i4, 5                                    
 201a058:	32 80 00 2f 	bne,a   201a114 <rtems_rfs_block_map_indirect_shrink+0xd0>
 201a05c:	b0 10 20 00 	clr  %i0                                       
 201a060:	80 a6 e0 00 	cmp  %i3, 0                                    
 201a064:	32 80 00 2c 	bne,a   201a114 <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
 201a068:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
      ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))         
  {                                                                   
    rtems_rfs_block_no block_to_free = map->blocks[indirect];         
 201a06c:	82 06 e0 08 	add  %i3, 8, %g1                               
                                                                      
    if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))         
 201a070:	80 a7 20 05 	cmp  %i4, 5                                    
   * 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];         
 201a074:	83 28 60 02 	sll  %g1, 2, %g1                               
 201a078:	82 06 40 01 	add  %i1, %g1, %g1                             
                                                                      
    if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))         
 201a07c:	12 80 00 1a 	bne  201a0e4 <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
 201a080:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
 201a084:	80 a6 e0 00 	cmp  %i3, 0                                    
 201a088:	32 80 00 18 	bne,a   201a0e8 <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
 201a08c:	b6 06 e0 08 	add  %i3, 8, %i3                               <== NOT EXECUTED
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
        map->blocks[b] = rtems_rfs_block_get_number (buffer, b);      
 201a090:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
 201a094:	84 10 20 00 	clr  %g2                                       
 201a098:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
 201a09c:	f8 08 40 00 	ldub  [ %g1 ], %i4                             
 201a0a0:	c8 08 60 01 	ldub  [ %g1 + 1 ], %g4                         
 201a0a4:	b9 2f 20 18 	sll  %i4, 0x18, %i4                            
 201a0a8:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 201a0ac:	88 17 00 04 	or  %i4, %g4, %g4                              
 201a0b0:	f8 08 60 03 	ldub  [ %g1 + 3 ], %i4                         
 * @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,     
 201a0b4:	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);      
 201a0b8:	88 11 00 1c 	or  %g4, %i4, %g4                              
 201a0bc:	f8 08 60 02 	ldub  [ %g1 + 2 ], %i4                         
 201a0c0:	84 00 a0 04 	add  %g2, 4, %g2                               
 201a0c4:	b9 2f 20 08 	sll  %i4, 8, %i4                               
 201a0c8:	88 11 00 1c 	or  %g4, %i4, %g4                              
 201a0cc:	c8 20 e0 24 	st  %g4, [ %g3 + 0x24 ]                        
    {                                                                 
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
 201a0d0:	80 a0 a0 14 	cmp  %g2, 0x14                                 
 201a0d4:	12 bf ff f2 	bne  201a09c <rtems_rfs_block_map_indirect_shrink+0x58>
 201a0d8:	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);      
 201a0dc:	10 80 00 07 	b  201a0f8 <rtems_rfs_block_map_indirect_shrink+0xb4>
 201a0e0:	90 10 00 18 	mov  %i0, %o0                                  
    else                                                              
    {                                                                 
      /*                                                              
       * One less singly indirect block in the inode.                 
       */                                                             
      map->blocks[indirect] = 0;                                      
 201a0e4:	b6 06 e0 08 	add  %i3, 8, %i3                               <== NOT EXECUTED
 201a0e8:	b7 2e e0 02 	sll  %i3, 2, %i3                               <== NOT EXECUTED
 201a0ec:	b6 06 40 1b 	add  %i1, %i3, %i3                             <== NOT EXECUTED
 201a0f0:	c0 26 e0 04 	clr  [ %i3 + 4 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
 201a0f4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201a0f8:	92 10 20 00 	clr  %o1                                       
 201a0fc:	7f ff de 29 	call  20119a0 <rtems_rfs_group_bitmap_free>    
 201a100:	94 10 00 1d 	mov  %i5, %o2                                  
    if (rc > 0)                                                       
 201a104:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201a108:	14 80 00 05 	bg  201a11c <rtems_rfs_block_map_indirect_shrink+0xd8><== NEVER TAKEN
 201a10c:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    map->last_map_block = block_to_free;                              
 201a110:	fa 26 60 1c 	st  %i5, [ %i1 + 0x1c ]                        
 201a114:	81 c7 e0 08 	ret                                            
 201a118:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 201a11c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201a120:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201a444 <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) {
 201a444:	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;                                                 
 201a448:	c0 2e 80 00 	clrb  [ %i2 ]                                  
  map->inode = NULL;                                                  
 201a44c:	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;                                                    
 201a450:	c0 26 a0 08 	clr  [ %i2 + 8 ]                               
  size->offset = 0;                                                   
 201a454:	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;                                                      
 201a458:	c0 26 a0 10 	clr  [ %i2 + 0x10 ]                            
  bpos->boff = 0;                                                     
 201a45c:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
  bpos->block = 0;                                                    
 201a460:	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;                                              
 201a464:	c0 2e a0 38 	clrb  [ %i2 + 0x38 ]                           
  handle->bnum  = 0;                                                  
 201a468:	c0 26 a0 3c 	clr  [ %i2 + 0x3c ]                            
  handle->buffer = NULL;                                              
 201a46c:	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;                                              
 201a470:	c0 2e a0 44 	clrb  [ %i2 + 0x44 ]                           
  handle->bnum  = 0;                                                  
 201a474:	c0 26 a0 48 	clr  [ %i2 + 0x48 ]                            
  handle->buffer = NULL;                                              
 201a478:	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);                              
 201a47c:	90 10 00 18 	mov  %i0, %o0                                  
 201a480:	7f ff dd ec 	call  2011c30 <rtems_rfs_inode_load>           
 201a484:	92 10 00 19 	mov  %i1, %o1                                  
  if (rc > 0)                                                         
 201a488:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201a48c:	14 80 00 40 	bg  201a58c <rtems_rfs_block_map_open+0x148>   <== NEVER TAKEN
 201a490:	84 10 20 00 	clr  %g2                                       
 * @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]);      
 201a494:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
                                                                      
  /*                                                                  
   * Extract the block and block count data from the inode into the targets
   * byte order.                                                      
   */                                                                 
  map->inode = inode;                                                 
 201a498:	f2 26 a0 04 	st  %i1, [ %i2 + 4 ]                           
 201a49c:	88 00 a0 06 	add  %g2, 6, %g4                               
 201a4a0:	89 29 20 02 	sll  %g4, 2, %g4                               
 201a4a4:	88 00 40 04 	add  %g1, %g4, %g4                             
 201a4a8:	86 01 20 04 	add  %g4, 4, %g3                               
 201a4ac:	f8 09 20 04 	ldub  [ %g4 + 4 ], %i4                         
 201a4b0:	c8 09 20 05 	ldub  [ %g4 + 5 ], %g4                         
 201a4b4:	b9 2f 20 18 	sll  %i4, 0x18, %i4                            
 201a4b8:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 201a4bc:	b8 17 00 04 	or  %i4, %g4, %i4                              
 201a4c0:	c8 08 e0 03 	ldub  [ %g3 + 3 ], %g4                         
  block_size = rtems_rfs_fs_block_size (fs);                          
  return (((uint64_t) (size->count - 1)) * block_size) + offset;      
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,                 
 201a4c4:	bb 28 a0 02 	sll  %g2, 2, %i5                               
 201a4c8:	b8 17 00 04 	or  %i4, %g4, %i4                              
 201a4cc:	c8 08 e0 02 	ldub  [ %g3 + 2 ], %g4                         
 201a4d0:	ba 06 80 1d 	add  %i2, %i5, %i5                             
 201a4d4:	89 29 20 08 	sll  %g4, 8, %g4                               
 201a4d8:	86 17 00 04 	or  %i4, %g4, %g3                              
  /*                                                                  
   * 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++)                        
 201a4dc:	84 00 a0 01 	inc  %g2                                       
 201a4e0:	80 a0 a0 05 	cmp  %g2, 5                                    
 201a4e4:	12 bf ff ee 	bne  201a49c <rtems_rfs_block_map_open+0x58>   
 201a4e8:	c6 27 60 24 	st  %g3, [ %i5 + 0x24 ]                        
 * @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);             
 201a4ec:	c6 08 60 0c 	ldub  [ %g1 + 0xc ], %g3                       
 201a4f0:	c4 08 60 0d 	ldub  [ %g1 + 0xd ], %g2                       
 201a4f4:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201a4f8:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201a4fc:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201a500:	c6 08 60 0f 	ldub  [ %g1 + 0xf ], %g3                       
 201a504:	84 10 80 03 	or  %g2, %g3, %g2                              
 201a508:	c6 08 60 0e 	ldub  [ %g1 + 0xe ], %g3                       
 201a50c:	87 28 e0 08 	sll  %g3, 8, %g3                               
 201a510:	84 10 80 03 	or  %g2, %g3, %g2                              
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
  map->size.count = rtems_rfs_inode_get_block_count (inode);          
 201a514:	c4 26 a0 08 	st  %g2, [ %i2 + 8 ]                           
  map->size.offset = rtems_rfs_inode_get_block_offset (inode);        
 201a518:	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);            
 201a51c:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
 201a520:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201a524:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201a528:	c4 26 a0 0c 	st  %g2, [ %i2 + 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);          
 201a52c:	c6 08 60 30 	ldub  [ %g1 + 0x30 ], %g3                      
 201a530:	c4 08 60 31 	ldub  [ %g1 + 0x31 ], %g2                      
 201a534:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201a538:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201a53c:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201a540:	c6 08 60 33 	ldub  [ %g1 + 0x33 ], %g3                      
 201a544:	84 10 80 03 	or  %g2, %g3, %g2                              
 201a548:	c6 08 60 32 	ldub  [ %g1 + 0x32 ], %g3                      
 201a54c:	87 28 e0 08 	sll  %g3, 8, %g3                               
 201a550:	84 10 80 03 	or  %g2, %g3, %g2                              
  map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);   
 201a554:	c4 26 a0 1c 	st  %g2, [ %i2 + 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);         
 201a558:	c4 08 60 35 	ldub  [ %g1 + 0x35 ], %g2                      
 201a55c:	c6 08 60 34 	ldub  [ %g1 + 0x34 ], %g3                      
 201a560:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201a564:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201a568:	86 10 c0 02 	or  %g3, %g2, %g3                              
 201a56c:	c4 08 60 37 	ldub  [ %g1 + 0x37 ], %g2                      
 201a570:	86 10 c0 02 	or  %g3, %g2, %g3                              
 201a574:	c4 08 60 36 	ldub  [ %g1 + 0x36 ], %g2                      
 201a578:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201a57c:	82 10 c0 02 	or  %g3, %g2, %g1                              
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
 201a580:	c2 26 a0 20 	st  %g1, [ %i2 + 0x20 ]                        
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
 201a584:	7f ff de 0e 	call  2011dbc <rtems_rfs_inode_unload>         
 201a588:	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);                       
 201a58c:	92 06 a0 38 	add  %i2, 0x38, %o1                            <== NOT EXECUTED
 201a590:	40 00 03 26 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201a594:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201a598:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
 201a59c:	c0 2e a0 38 	clrb  [ %i2 + 0x38 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201a5a0:	c0 26 a0 3c 	clr  [ %i2 + 0x3c ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201a5a4:	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);                       
 201a5a8:	92 06 a0 44 	add  %i2, 0x44, %o1                            <== NOT EXECUTED
 201a5ac:	40 00 03 1f 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201a5b0:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
 201a5b4:	c0 2e a0 44 	clrb  [ %i2 + 0x44 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201a5b8:	c0 26 a0 48 	clr  [ %i2 + 0x48 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201a5bc:	c0 26 a0 4c 	clr  [ %i2 + 0x4c ]                            <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
 201a5c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201a5c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201ad70 <rtems_rfs_block_map_shrink>: int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks) {
 201ad70:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))             
 201ad74:	90 10 20 00 	clr  %o0                                       
 201ad78:	7f ff e2 64 	call  2013708 <rtems_rfs_trace>                
 201ad7c:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
 201ad80:	80 8a 20 ff 	btst  0xff, %o0                                
 201ad84:	22 80 00 08 	be,a   201ada4 <rtems_rfs_block_map_shrink+0x34><== ALWAYS TAKEN
 201ad88:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
 201ad8c:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           <== NOT EXECUTED
 201ad90:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201ad94:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201ad98:	40 00 1c 7b 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ad9c:	90 12 21 a8 	or  %o0, 0x1a8, %o0                            <== NOT EXECUTED
            blocks, map->size.count);                                 
                                                                      
  if (map->size.count == 0)                                           
 201ada0:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
 201ada4:	80 a0 60 00 	cmp  %g1, 0                                    
 201ada8:	12 80 00 04 	bne  201adb8 <rtems_rfs_block_map_shrink+0x48> 
 201adac:	80 a6 80 01 	cmp  %i2, %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);           
                                                                      
  return 0;                                                           
 201adb0:	10 80 00 b8 	b  201b090 <rtems_rfs_block_map_shrink+0x320>  
 201adb4:	90 10 20 00 	clr  %o0                                       
 201adb8:	38 80 00 90 	bgu,a   201aff8 <rtems_rfs_block_map_shrink+0x288><== NEVER TAKEN
 201adbc:	b4 10 00 01 	mov  %g1, %i2                                  <== NOT EXECUTED
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
        doubly_singly = singly % fs->blocks_per_block;                
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
 201adc0:	10 80 00 8f 	b  201affc <rtems_rfs_block_map_shrink+0x28c>  
 201adc4:	a4 06 60 44 	add  %i1, 0x44, %l2                            
  {                                                                   
    rtems_rfs_block_no block;                                         
    rtems_rfs_block_no block_to_free;                                 
    int                rc;                                            
                                                                      
    block = map->size.count - 1;                                      
 201adc8:	ba 00 7f ff 	add  %g1, -1, %i5                              
                                                                      
    if (block < RTEMS_RFS_INODE_BLOCKS)                               
 201adcc:	80 a7 60 04 	cmp  %i5, 4                                    
 201add0:	38 80 00 08 	bgu,a   201adf0 <rtems_rfs_block_map_shrink+0x80>
 201add4:	f6 06 20 34 	ld  [ %i0 + 0x34 ], %i3                        
    {                                                                 
      /*                                                              
       * We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
       * inode.                                                       
       */                                                             
      block_to_free = map->blocks[block];                             
 201add8:	82 00 60 07 	add  %g1, 7, %g1                               
 201addc:	83 28 60 02 	sll  %g1, 2, %g1                               
 201ade0:	82 06 40 01 	add  %i1, %g1, %g1                             
 201ade4:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
      map->blocks[block] = 0;                                         
 201ade8:	10 80 00 76 	b  201afc0 <rtems_rfs_block_map_shrink+0x250>  
 201adec:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
       * table of block numbers.                                      
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
 201adf0:	90 10 00 1d 	mov  %i5, %o0                                  
 201adf4:	40 00 4c e5 	call  202e188 <.urem>                          
 201adf8:	92 10 00 1b 	mov  %i3, %o1                                  
      singly = block / fs->blocks_per_block;                          
 201adfc:	92 10 00 1b 	mov  %i3, %o1                                  
       * table of block numbers.                                      
       */                                                             
      rtems_rfs_block_no direct;                                      
      rtems_rfs_block_no singly;                                      
                                                                      
      direct = block % fs->blocks_per_block;                          
 201ae00:	b8 10 00 08 	mov  %o0, %i4                                  
      singly = block / fs->blocks_per_block;                          
 201ae04:	7f ff 9e 1e 	call  200267c <.udiv>                          
 201ae08:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (block < fs->block_map_singly_blocks)                        
 201ae0c:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
 201ae10:	80 a7 40 01 	cmp  %i5, %g1                                  
 201ae14:	1a 80 00 20 	bcc  201ae94 <rtems_rfs_block_map_shrink+0x124><== NEVER TAKEN
 201ae18:	a2 10 00 08 	mov  %o0, %l1                                  
      {                                                               
        /*                                                            
         * Request the indirect block and then obtain the block number from the
         * indirect block.                                            
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201ae1c:	82 02 20 08 	add  %o0, 8, %g1                               
 201ae20:	83 28 60 02 	sll  %g1, 2, %g1                               
 201ae24:	82 06 40 01 	add  %i1, %g1, %g1                             
 201ae28:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
 201ae2c:	90 10 00 18 	mov  %i0, %o0                                  
 201ae30:	92 10 00 10 	mov  %l0, %o1                                  
 201ae34:	40 00 01 71 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201ae38:	96 10 20 01 	mov  1, %o3                                    
                                              map->blocks[singly], true);
        if (rc > 0)                                                   
 201ae3c:	80 a2 20 00 	cmp  %o0, 0                                    
 201ae40:	14 80 00 94 	bg  201b090 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
 201ae44:	85 2f 20 02 	sll  %i4, 2, %g2                               
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
 201ae48:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
 201ae4c:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
 201ae50:	90 10 00 18 	mov  %i0, %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,
 201ae54:	82 00 c0 02 	add  %g3, %g2, %g1                             
 201ae58:	fa 08 c0 02 	ldub  [ %g3 + %g2 ], %i5                       
 201ae5c:	c8 08 60 03 	ldub  [ %g1 + 3 ], %g4                         
 201ae60:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         
 201ae64:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         
 201ae68:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
 201ae6c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201ae70:	ba 11 00 1d 	or  %g4, %i5, %i5                              
 201ae74:	83 28 60 08 	sll  %g1, 8, %g1                               
 201ae78:	ba 17 40 02 	or  %i5, %g2, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
 201ae7c:	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,
 201ae80:	ba 17 40 01 	or  %i5, %g1, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
 201ae84:	94 10 00 10 	mov  %l0, %o2                                  
 201ae88:	96 10 00 11 	mov  %l1, %o3                                  
 201ae8c:	10 80 00 48 	b  201afac <rtems_rfs_block_map_shrink+0x23c>  
 201ae90:	98 10 00 1c 	mov  %i4, %o4                                  
                                                  singly, direct);    
        if (rc)                                                       
          return rc;                                                  
      }                                                               
      else if (block < fs->block_map_doubly_blocks)                   
 201ae94:	c2 06 20 3c 	ld  [ %i0 + 0x3c ], %g1                        <== NOT EXECUTED
 201ae98:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
 201ae9c:	3a 80 00 5d 	bcc,a   201b010 <rtems_rfs_block_map_shrink+0x2a0><== NOT EXECUTED
 201aea0:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== 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;                
 201aea4:	7f ff 9d f6 	call  200267c <.udiv>                          <== NOT EXECUTED
 201aea8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
 201aeac:	92 10 00 1b 	mov  %i3, %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;                
 201aeb0:	a8 10 00 08 	mov  %o0, %l4                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
 201aeb4:	40 00 4c b5 	call  202e188 <.urem>                          <== NOT EXECUTED
 201aeb8:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
 201aebc:	82 05 20 08 	add  %l4, 8, %g1                               <== NOT EXECUTED
 201aec0:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
 201aec4:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
 201aec8:	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;                
 201aecc:	a2 10 00 08 	mov  %o0, %l1                                  <== NOT EXECUTED
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
 201aed0:	92 10 00 12 	mov  %l2, %o1                                  <== NOT EXECUTED
 201aed4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201aed8:	40 00 01 48 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201aedc:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                              map->blocks[doubly], true);
        if (rc > 0)                                                   
 201aee0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201aee4:	14 80 00 6b 	bg  201b090 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
 201aee8:	85 2c 60 02 	sll  %l1, 2, %g2                               <== NOT EXECUTED
          return rc;                                                  
                                                                      
        singly = rtems_rfs_block_get_number (&map->doubly_buffer,     
 201aeec:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
 201aef0:	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,
 201aef4:	90 10 00 18 	mov  %i0, %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,     
 201aef8:	82 00 c0 02 	add  %g3, %g2, %g1                             <== NOT EXECUTED
 201aefc:	f6 08 c0 02 	ldub  [ %g3 + %g2 ], %i3                       <== NOT EXECUTED
 201af00:	c8 08 60 03 	ldub  [ %g1 + 3 ], %g4                         <== NOT EXECUTED
 201af04:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
 201af08:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
 201af0c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
 201af10:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
 201af14:	b7 2e e0 18 	sll  %i3, 0x18, %i3                            <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201af18:	92 10 00 10 	mov  %l0, %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,     
 201af1c:	b6 11 00 1b 	or  %g4, %i3, %i3                              <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201af20:	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,     
 201af24:	b6 16 c0 02 	or  %i3, %g2, %i3                              <== NOT EXECUTED
 201af28:	b6 16 c0 01 	or  %i3, %g1, %i3                              <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201af2c:	40 00 01 33 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201af30:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
                                              singly, true);          
        if (rc > 0)                                                   
 201af34:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201af38:	14 80 00 56 	bg  201b090 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
 201af3c:	85 2f 20 02 	sll  %i4, 2, %g2                               <== NOT EXECUTED
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
 201af40:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        <== NOT EXECUTED
 201af44:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
 201af48:	80 a7 20 00 	cmp  %i4, 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,
 201af4c:	82 00 c0 02 	add  %g3, %g2, %g1                             <== NOT EXECUTED
 201af50:	fa 08 c0 02 	ldub  [ %g3 + %g2 ], %i5                       <== NOT EXECUTED
 201af54:	c8 08 60 03 	ldub  [ %g1 + 3 ], %g4                         <== NOT EXECUTED
 201af58:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
 201af5c:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
 201af60:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            <== NOT EXECUTED
 201af64:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
 201af68:	ba 11 00 1d 	or  %g4, %i5, %i5                              <== NOT EXECUTED
 201af6c:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
 201af70:	ba 17 40 02 	or  %i5, %g2, %i5                              <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
 201af74:	12 80 00 13 	bne  201afc0 <rtems_rfs_block_map_shrink+0x250><== NOT EXECUTED
 201af78:	ba 17 40 01 	or  %i5, %g1, %i5                              <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_group_bitmap_free (fs, false, singly);       
 201af7c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201af80:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201af84:	7f ff da 87 	call  20119a0 <rtems_rfs_group_bitmap_free>    <== NOT EXECUTED
 201af88:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
          if (rc > 0)                                                 
 201af8c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201af90:	14 80 00 40 	bg  201b090 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
 201af94:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
            return rc;                                                
                                                                      
          map->last_map_block = singly;                               
 201af98:	f6 26 60 1c 	st  %i3, [ %i1 + 0x1c ]                        <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
 201af9c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201afa0:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
 201afa4:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
 201afa8:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
 201afac:	7f ff fc 26 	call  201a044 <rtems_rfs_block_map_indirect_shrink>
 201afb0:	01 00 00 00 	nop                                            
                                                    doubly, doubly_singly);
          if (rc)                                                     
 201afb4:	80 a2 20 00 	cmp  %o0, 0                                    
 201afb8:	12 80 00 36 	bne  201b090 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
 201afbc:	01 00 00 00 	nop                                            
      {                                                               
        rc = EIO;                                                     
        break;                                                        
      }                                                               
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
 201afc0:	90 10 00 18 	mov  %i0, %o0                                  
 201afc4:	92 10 20 00 	clr  %o1                                       
 201afc8:	7f ff da 76 	call  20119a0 <rtems_rfs_group_bitmap_free>    
 201afcc:	94 10 00 1d 	mov  %i5, %o2                                  
    if (rc > 0)                                                       
 201afd0:	80 a2 20 00 	cmp  %o0, 0                                    
 201afd4:	14 80 00 2f 	bg  201b090 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
 201afd8:	b4 06 bf ff 	add  %i2, -1, %i2                              
      return rc;                                                      
    map->size.count--;                                                
 201afdc:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    map->size.offset = 0;                                             
 201afe0:	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--;                                                
 201afe4:	82 00 7f ff 	add  %g1, -1, %g1                              
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
 201afe8:	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--;                                                
 201afec:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
 201aff0:	10 80 00 05 	b  201b004 <rtems_rfs_block_map_shrink+0x294>  
 201aff4:	e6 2e 40 00 	stb  %l3, [ %i1 ]                              
        rtems_rfs_block_no doubly_singly;                             
                                                                      
        doubly        = singly / fs->blocks_per_block;                
        doubly_singly = singly % fs->blocks_per_block;                
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
 201aff8:	a4 06 60 44 	add  %i1, 0x44, %l2                            <== NOT EXECUTED
                                             doubly_singly);          
                                                                      
        /*                                                            
         * Read the singly indirect table and get the block number.   
         */                                                           
        rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
 201affc:	a0 06 60 38 	add  %i1, 0x38, %l0                            
    if (rc > 0)                                                       
      return rc;                                                      
    map->size.count--;                                                
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
 201b000:	a6 10 20 01 	mov  1, %l3                                    
    return 0;                                                         
                                                                      
  if (blocks > map->size.count)                                       
    blocks = map->size.count;                                         
                                                                      
  while (blocks)                                                      
 201b004:	80 a6 a0 00 	cmp  %i2, 0                                    
 201b008:	12 bf ff 70 	bne  201adc8 <rtems_rfs_block_map_shrink+0x58> 
 201b00c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
    blocks--;                                                         
  }                                                                   
                                                                      
  if (map->size.count == 0)                                           
 201b010:	80 a0 60 00 	cmp  %g1, 0                                    
 201b014:	32 80 00 05 	bne,a   201b028 <rtems_rfs_block_map_shrink+0x2b8>
 201b018:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
  {                                                                   
    map->last_map_block = 0;                                          
 201b01c:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    map->last_data_block = 0;                                         
 201b020:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
  }                                                                   
                                                                      
  /*                                                                  
   * Keep the position inside the map.                                
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
 201b024:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
 201b028:	80 a0 a0 00 	cmp  %g2, 0                                    
 201b02c:	02 80 00 06 	be  201b044 <rtems_rfs_block_map_shrink+0x2d4> 
 201b030:	80 a0 80 01 	cmp  %g2, %g1                                  
 201b034:	80 a0 60 00 	cmp  %g1, 0                                    
 201b038:	22 80 00 0e 	be,a   201b070 <rtems_rfs_block_map_shrink+0x300><== ALWAYS TAKEN
 201b03c:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 201b040:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
 201b044:	3a 80 00 0b 	bcc,a   201b070 <rtems_rfs_block_map_shrink+0x300>
 201b048:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 201b04c:	86 00 7f ff 	add  %g1, -1, %g3                              
 201b050:	80 a0 80 03 	cmp  %g2, %g3                                  
 201b054:	12 80 00 0f 	bne  201b090 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
 201b058:	90 10 20 00 	clr  %o0                                       
 201b05c:	c6 06 60 14 	ld  [ %i1 + 0x14 ], %g3                        
 201b060:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 201b064:	80 a0 c0 02 	cmp  %g3, %g2                                  
 201b068:	08 80 00 0a 	bleu  201b090 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
 201b06c:	01 00 00 00 	nop                                            
    rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);           
 201b070:	c2 26 60 10 	st  %g1, [ %i1 + 0x10 ]                        
 201b074:	c4 26 60 14 	st  %g2, [ %i1 + 0x14 ]                        
 201b078:	80 a0 a0 00 	cmp  %g2, 0                                    
 201b07c:	02 80 00 04 	be  201b08c <rtems_rfs_block_map_shrink+0x31c> <== ALWAYS TAKEN
 201b080:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
 201b084:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
 201b088:	c2 26 60 10 	st  %g1, [ %i1 + 0x10 ]                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
 201b08c:	90 10 20 00 	clr  %o0                                       
}                                                                     
 201b090:	81 c7 e0 08 	ret                                            
 201b094:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020205c0 <rtems_rfs_buffer_bdbuf_release>: int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer, bool modified) {
 20205c0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc;                                               
  int               rc = 0;                                           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
 20205c4:	90 10 20 00 	clr  %o0                                       
 20205c8:	7f ff cc 50 	call  2013708 <rtems_rfs_trace>                
 20205cc:	92 10 20 40 	mov  0x40, %o1                                 
 20205d0:	80 8a 20 ff 	btst  0xff, %o0                                
 20205d4:	02 80 00 0e 	be  202060c <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
 20205d8:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
 20205dc:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        <== NOT EXECUTED
 20205e0:	02 80 00 05 	be  20205f4 <rtems_rfs_buffer_bdbuf_release+0x34><== NOT EXECUTED
 20205e4:	d4 06 20 18 	ld  [ %i0 + 0x18 ], %o2                        <== NOT EXECUTED
 20205e8:	17 00 80 d3 	sethi  %hi(0x2034c00), %o3                     <== NOT EXECUTED
 20205ec:	10 80 00 04 	b  20205fc <rtems_rfs_buffer_bdbuf_release+0x3c><== NOT EXECUTED
 20205f0:	96 12 e1 a8 	or  %o3, 0x1a8, %o3	! 2034da8 <rtems_termios_baud_table+0x100><== NOT EXECUTED
 20205f4:	17 00 80 c2 	sethi  %hi(0x2030800), %o3                     <== NOT EXECUTED
 20205f8:	96 12 e3 10 	or  %o3, 0x310, %o3	! 2030b10 <__FUNCTION__.7127+0x438><== NOT EXECUTED
 20205fc:	11 00 80 d3 	sethi  %hi(0x2034c00), %o0                     <== NOT EXECUTED
 2020600:	40 00 06 61 	call  2021f84 <printf>                         <== NOT EXECUTED
 2020604:	90 12 21 b8 	or  %o0, 0x1b8, %o0	! 2034db8 <rtems_termios_baud_table+0x110><== NOT EXECUTED
            ((intptr_t) buffer->user),                                
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
 2020608:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
 202060c:	02 80 00 06 	be  2020624 <rtems_rfs_buffer_bdbuf_release+0x64>
 2020610:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_release_modified (buffer);                       
 2020614:	7f ff d5 3a 	call  2015afc <rtems_bdbuf_release_modified>   
 2020618:	01 00 00 00 	nop                                            
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
 202061c:	10 80 00 05 	b  2020630 <rtems_rfs_buffer_bdbuf_release+0x70>
 2020620:	80 a0 00 08 	cmp  %g0, %o0                                  
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
    sc = rtems_bdbuf_release_modified (buffer);                       
  else                                                                
    sc = rtems_bdbuf_release (buffer);                                
 2020624:	7f ff d5 01 	call  2015a28 <rtems_bdbuf_release>            
 2020628:	01 00 00 00 	nop                                            
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
 202062c:	80 a0 00 08 	cmp  %g0, %o0                                  
 2020630:	b0 60 20 00 	subx  %g0, 0, %i0                              
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 2020634:	b0 0e 20 05 	and  %i0, 5, %i0                               
 2020638:	81 c7 e0 08 	ret                                            
 202063c:	81 e8 00 00 	restore                                        
                                                                      

0201b9fc <rtems_rfs_buffer_close>: return 0; } int rtems_rfs_buffer_close (rtems_rfs_file_system* fs) {
 201b9fc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))                 
 201ba00:	90 10 20 00 	clr  %o0                                       
 201ba04:	7f ff df 41 	call  2013708 <rtems_rfs_trace>                
 201ba08:	92 10 20 10 	mov  0x10, %o1                                 
 201ba0c:	80 8a 20 ff 	btst  0xff, %o0                                
 201ba10:	22 80 00 06 	be,a   201ba28 <rtems_rfs_buffer_close+0x2c>   <== ALWAYS TAKEN
 201ba14:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
    printf ("rtems-rfs: buffer-close: closing\n");                    
 201ba18:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201ba1c:	40 00 19 f2 	call  20221e4 <puts>                           <== NOT EXECUTED
 201ba20:	90 12 22 80 	or  %o0, 0x280, %o0	! 2033a80 <CSWTCH.2+0x5a0> <== 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));
 201ba24:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        <== NOT EXECUTED
 201ba28:	90 10 00 18 	mov  %i0, %o0                                  
 201ba2c:	7f ff ff b9 	call  201b910 <rtems_rfs_buffer_setblksize>    
 201ba30:	d2 00 60 20 	ld  [ %g1 + 0x20 ], %o1                        
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))     
 201ba34:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201ba38:	04 80 00 0e 	ble  201ba70 <rtems_rfs_buffer_close+0x74>     <== ALWAYS TAKEN
 201ba3c:	90 10 20 00 	clr  %o0                                       
 201ba40:	7f ff df 32 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201ba44:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
 201ba48:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201ba4c:	02 80 00 09 	be  201ba70 <rtems_rfs_buffer_close+0x74>      <== NOT EXECUTED
 201ba50:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
 201ba54:	40 00 1d b8 	call  2023134 <strerror>                       <== NOT EXECUTED
 201ba58:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ba5c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201ba60:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201ba64:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201ba68:	40 00 19 47 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ba6c:	90 12 22 a8 	or  %o0, 0x2a8, %o0	! 2033aa8 <CSWTCH.2+0x5c8> <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  if (close (fs->device) < 0)                                         
 201ba70:	7f ff b0 a0 	call  2007cf0 <close>                          
 201ba74:	d0 06 20 0c 	ld  [ %i0 + 0xc ], %o0                         
 201ba78:	80 a2 20 00 	cmp  %o0, 0                                    
 201ba7c:	16 80 00 12 	bge  201bac4 <rtems_rfs_buffer_close+0xc8>     <== ALWAYS TAKEN
 201ba80:	01 00 00 00 	nop                                            
  {                                                                   
    rc = errno;                                                       
 201ba84:	40 00 13 e7 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201ba88:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))               
 201ba8c:	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;                                                       
 201ba90:	fa 02 00 00 	ld  [ %o0 ], %i5                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))               
 201ba94:	7f ff df 1d 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201ba98:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201ba9c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201baa0:	02 80 00 09 	be  201bac4 <rtems_rfs_buffer_close+0xc8>      <== NOT EXECUTED
 201baa4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 
 201baa8:	40 00 1d a3 	call  2023134 <strerror>                       <== NOT EXECUTED
 201baac:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201bab0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201bab4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201bab8:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201babc:	40 00 19 32 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bac0:	90 12 22 e8 	or  %o0, 0x2e8, %o0	! 2033ae8 <CSWTCH.2+0x608> <== NOT EXECUTED
              rc, strerror (rc));                                     
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 201bac4:	81 c7 e0 08 	ret                                            
 201bac8:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

0201b228 <rtems_rfs_buffer_handle_release>: } int rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle) {
 201b228:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
 201b22c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_handle_release (rtems_rfs_file_system*   fs,         
                                 rtems_rfs_buffer_handle* handle)     
{                                                                     
 201b230:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
 201b234:	80 a0 60 00 	cmp  %g1, 0                                    
 201b238:	02 80 00 6e 	be  201b3f0 <rtems_rfs_buffer_handle_release+0x1c8>
 201b23c:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
 201b240:	90 10 20 00 	clr  %o0                                       
 201b244:	7f ff e1 31 	call  2013708 <rtems_rfs_trace>                
 201b248:	92 10 22 00 	mov  0x200, %o1                                
 201b24c:	80 8a 20 ff 	btst  0xff, %o0                                
 201b250:	22 80 00 18 	be,a   201b2b0 <rtems_rfs_buffer_handle_release+0x88><== ALWAYS TAKEN
 201b254:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           
      printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
 201b258:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             <== NOT EXECUTED
 201b25c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 201b260:	02 80 00 05 	be  201b274 <rtems_rfs_buffer_handle_release+0x4c><== NOT EXECUTED
 201b264:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           <== NOT EXECUTED
 201b268:	15 00 80 cd 	sethi  %hi(0x2033400), %o2                     <== NOT EXECUTED
 201b26c:	10 80 00 04 	b  201b27c <rtems_rfs_buffer_handle_release+0x54><== NOT EXECUTED
 201b270:	94 12 a2 70 	or  %o2, 0x270, %o2	! 2033670 <CSWTCH.2+0x190> <== NOT EXECUTED
 201b274:	15 00 80 c2 	sethi  %hi(0x2030800), %o2                     <== NOT EXECUTED
 201b278:	94 12 a3 10 	or  %o2, 0x310, %o2	! 2030b10 <__FUNCTION__.7127+0x438><== 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" : "");
 201b27c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
 201b280:	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",
 201b284:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
 201b288:	32 80 00 05 	bne,a   201b29c <rtems_rfs_buffer_handle_release+0x74><== NOT EXECUTED
 201b28c:	19 00 80 c2 	sethi  %hi(0x2030800), %o4                     <== NOT EXECUTED
 201b290:	19 00 80 cd 	sethi  %hi(0x2033400), %o4                     <== NOT EXECUTED
 201b294:	10 80 00 03 	b  201b2a0 <rtems_rfs_buffer_handle_release+0x78><== NOT EXECUTED
 201b298:	98 13 22 78 	or  %o4, 0x278, %o4	! 2033678 <CSWTCH.2+0x198> <== NOT EXECUTED
 201b29c:	98 13 23 10 	or  %o4, 0x310, %o4                            <== NOT EXECUTED
 201b2a0:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b2a4:	40 00 1b 38 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b2a8:	90 12 22 88 	or  %o0, 0x288, %o0	! 2033688 <CSWTCH.2+0x1a8> <== 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)                           
 201b2ac:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           <== NOT EXECUTED
 201b2b0:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1                        
 201b2b4:	80 a0 60 00 	cmp  %g1, 0                                    
 201b2b8:	04 80 00 03 	ble  201b2c4 <rtems_rfs_buffer_handle_release+0x9c><== NEVER TAKEN
 201b2bc:	82 00 7f ff 	add  %g1, -1, %g1                              
      rtems_rfs_buffer_refs_down (handle);                            
 201b2c0:	c2 22 20 30 	st  %g1, [ %o0 + 0x30 ]                        
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
 201b2c4:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1                        
 201b2c8:	80 a0 60 00 	cmp  %g1, 0                                    
 201b2cc:	12 80 00 48 	bne  201b3ec <rtems_rfs_buffer_handle_release+0x1c4>
 201b2d0:	b0 10 20 00 	clr  %i0                                       
 201b2d4:	7f ff f3 d1 	call  2018218 <_Chain_Extract>                 
 201b2d8:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
 201b2dc:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
 201b2e0:	f0 07 40 00 	ld  [ %i5 ], %i0                               
      rtems_rfs_buffer_refs_down (handle);                            
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
    {                                                                 
      rtems_chain_extract (rtems_rfs_buffer_link (handle));           
      fs->buffers_count--;                                            
 201b2e4:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
 201b2e8:	b0 8e 20 02 	andcc  %i0, 2, %i0                             
 201b2ec:	02 80 00 08 	be  201b30c <rtems_rfs_buffer_handle_release+0xe4>
 201b2f0:	c2 27 60 50 	st  %g1, [ %i5 + 0x50 ]                        
      {                                                               
        handle->buffer->user = (void*) 0;                             
 201b2f4:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           
        rc = rtems_rfs_buffer_io_release (handle->buffer,             
 201b2f8:	d2 0e 40 00 	ldub  [ %i1 ], %o1                             
 201b2fc:	40 00 14 b1 	call  20205c0 <rtems_rfs_buffer_bdbuf_release> 
 201b300:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
 201b304:	10 80 00 3a 	b  201b3ec <rtems_rfs_buffer_handle_release+0x1c4>
 201b308:	b0 10 00 08 	mov  %o0, %i0                                  
         * 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 +                                      
 201b30c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 201b310:	c4 07 60 70 	ld  [ %i5 + 0x70 ], %g2                        
 201b314:	84 00 80 01 	add  %g2, %g1, %g2                             
 201b318:	c2 07 60 40 	ld  [ %i5 + 0x40 ], %g1                        
 201b31c:	80 a0 80 01 	cmp  %g2, %g1                                  
 201b320:	2a 80 00 25 	bcs,a   201b3b4 <rtems_rfs_buffer_handle_release+0x18c>
 201b324:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
             fs->release_modified_count) >= fs->max_held_buffers)     
        {                                                             
          rtems_rfs_buffer* buffer;                                   
          bool              modified;                                 
                                                                      
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
 201b328:	90 10 20 00 	clr  %o0                                       
 201b32c:	7f ff e0 f7 	call  2013708 <rtems_rfs_trace>                
 201b330:	92 10 22 00 	mov  0x200, %o1                                
 201b334:	80 8a 20 ff 	btst  0xff, %o0                                
 201b338:	22 80 00 09 	be,a   201b35c <rtems_rfs_buffer_handle_release+0x134><== ALWAYS TAKEN
 201b33c:	c4 07 60 60 	ld  [ %i5 + 0x60 ], %g2                        
            printf ("rtems-rfs: buffer-release: local cache overflow:"
 201b340:	d2 07 60 70 	ld  [ %i5 + 0x70 ], %o1                        <== NOT EXECUTED
 201b344:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        <== NOT EXECUTED
 201b348:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b34c:	92 02 40 01 	add  %o1, %g1, %o1                             <== NOT EXECUTED
 201b350:	40 00 1b 0d 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b354:	90 12 22 c0 	or  %o0, 0x2c0, %o0                            <== NOT EXECUTED
                    " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
                                                                      
          if (fs->release_count > fs->release_modified_count)         
 201b358:	c4 07 60 60 	ld  [ %i5 + 0x60 ], %g2                        <== NOT EXECUTED
 201b35c:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
 201b360:	80 a0 80 01 	cmp  %g2, %g1                                  
 201b364:	08 80 00 09 	bleu  201b388 <rtems_rfs_buffer_handle_release+0x160>
 201b368:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
 201b36c:	7f ff c8 86 	call  200d584 <_Chain_Get>                     
 201b370:	90 07 60 54 	add  %i5, 0x54, %o0                            
          {                                                           
            buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
            fs->release_count--;                                      
 201b374:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
            modified = false;                                         
 201b378:	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--;                                      
 201b37c:	82 00 7f ff 	add  %g1, -1, %g1                              
 201b380:	10 80 00 08 	b  201b3a0 <rtems_rfs_buffer_handle_release+0x178>
 201b384:	c2 27 60 60 	st  %g1, [ %i5 + 0x60 ]                        
 201b388:	7f ff c8 7f 	call  200d584 <_Chain_Get>                     
 201b38c:	90 07 60 64 	add  %i5, 0x64, %o0                            
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
 201b390:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
            modified = true;                                          
 201b394:	92 10 20 01 	mov  1, %o1                                    
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
 201b398:	82 00 7f ff 	add  %g1, -1, %g1                              
 201b39c:	c2 27 60 70 	st  %g1, [ %i5 + 0x70 ]                        
            modified = true;                                          
          }                                                           
          buffer->user = (void*) 0;                                   
 201b3a0:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
          rc = rtems_rfs_buffer_io_release (buffer, modified);        
 201b3a4:	40 00 14 87 	call  20205c0 <rtems_rfs_buffer_bdbuf_release> 
 201b3a8:	92 0a 60 01 	and  %o1, 1, %o1                               
 201b3ac:	b0 10 00 08 	mov  %o0, %i0                                  
        }                                                             
                                                                      
        if (rtems_rfs_buffer_dirty (handle))                          
 201b3b0:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
 201b3b4:	80 a0 60 00 	cmp  %g1, 0                                    
 201b3b8:	02 80 00 08 	be  201b3d8 <rtems_rfs_buffer_handle_release+0x1b0>
 201b3bc:	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 );                               
 201b3c0:	7f ff c8 65 	call  200d554 <_Chain_Append>                  
 201b3c4:	90 07 60 64 	add  %i5, 0x64, %o0                            
        {                                                             
          rtems_chain_append (&fs->release_modified,                  
                              rtems_rfs_buffer_link (handle));        
          fs->release_modified_count++;                               
 201b3c8:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
 201b3cc:	82 00 60 01 	inc  %g1                                       
 201b3d0:	10 80 00 07 	b  201b3ec <rtems_rfs_buffer_handle_release+0x1c4>
 201b3d4:	c2 27 60 70 	st  %g1, [ %i5 + 0x70 ]                        
 201b3d8:	7f ff c8 5f 	call  200d554 <_Chain_Append>                  
 201b3dc:	90 07 60 54 	add  %i5, 0x54, %o0                            
        }                                                             
        else                                                          
        {                                                             
          rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
          fs->release_count++;                                        
 201b3e0:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 201b3e4:	82 00 60 01 	inc  %g1                                       
 201b3e8:	c2 27 60 60 	st  %g1, [ %i5 + 0x60 ]                        
        }                                                             
      }                                                               
    }                                                                 
    handle->buffer = NULL;                                            
 201b3ec:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 201b3f0:	81 c7 e0 08 	ret                                            
 201b3f4:	81 e8 00 00 	restore                                        
                                                                      

0201b3f8 <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) {
 201b3f8:	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))                     
 201b3fc:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201b400:	80 a0 60 00 	cmp  %g1, 0                                    
 201b404:	02 80 00 1a 	be  201b46c <rtems_rfs_buffer_handle_request+0x74>
 201b408:	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))           
 201b40c:	80 a6 a0 00 	cmp  %i2, 0                                    
 201b410:	02 80 00 06 	be  201b428 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
 201b414:	90 10 20 00 	clr  %o0                                       
 201b418:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 201b41c:	80 a0 40 1a 	cmp  %g1, %i2                                  
 201b420:	02 80 00 75 	be  201b5f4 <rtems_rfs_buffer_handle_request+0x1fc>
 201b424:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
 201b428:	7f ff e0 b8 	call  2013708 <rtems_rfs_trace>                
 201b42c:	92 10 21 00 	mov  0x100, %o1                                
 201b430:	80 8a 20 ff 	btst  0xff, %o0                                
 201b434:	22 80 00 07 	be,a   201b450 <rtems_rfs_buffer_handle_request+0x58><== ALWAYS TAKEN
 201b438:	90 10 00 1d 	mov  %i5, %o0                                  
      printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
 201b43c:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           <== NOT EXECUTED
 201b440:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b444:	40 00 1a d0 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b448:	90 12 23 00 	or  %o0, 0x300, %o0	! 2033700 <CSWTCH.2+0x220> <== NOT EXECUTED
              rtems_rfs_buffer_bnum (handle));                        
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
 201b44c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201b450:	7f ff ff 76 	call  201b228 <rtems_rfs_buffer_handle_release>
 201b454:	92 10 00 19 	mov  %i1, %o1                                  
    if (rc > 0)                                                       
 201b458:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201b45c:	14 80 00 8b 	bg  201b688 <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
 201b460:	01 00 00 00 	nop                                            
      return rc;                                                      
    handle->dirty = false;                                            
 201b464:	c0 2e 40 00 	clrb  [ %i1 ]                                  
    handle->bnum = 0;                                                 
 201b468:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
 201b46c:	90 10 20 00 	clr  %o0                                       
 201b470:	7f ff e0 a6 	call  2013708 <rtems_rfs_trace>                
 201b474:	92 10 21 00 	mov  0x100, %o1                                
 201b478:	80 8a 20 ff 	btst  0xff, %o0                                
 201b47c:	22 80 00 07 	be,a   201b498 <rtems_rfs_buffer_handle_request+0xa0><== ALWAYS TAKEN
 201b480:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block); 
 201b484:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b488:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201b48c:	40 00 1a be 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b490:	90 12 23 38 	or  %o0, 0x338, %o0                            <== 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)                                              
 201b494:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        <== NOT EXECUTED
 201b498:	80 a0 60 00 	cmp  %g1, 0                                    
 201b49c:	22 80 00 16 	be,a   201b4f4 <rtems_rfs_buffer_handle_request+0xfc>
 201b4a0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
  {                                                                   
    /*                                                                
     * Check the active buffer list for shared buffers.               
     */                                                               
    handle->buffer = rtems_rfs_scan_chain (&fs->buffers,              
 201b4a4:	90 07 60 44 	add  %i5, 0x44, %o0                            
 201b4a8:	92 07 60 50 	add  %i5, 0x50, %o1                            
 201b4ac:	7f ff ff 22 	call  201b134 <rtems_rfs_scan_chain>           
 201b4b0:	94 10 00 1a 	mov  %i2, %o2                                  
                                           &fs->buffers_count,        
                                           block);                    
    if (rtems_rfs_buffer_handle_has_block (handle) &&                 
 201b4b4:	80 a2 20 00 	cmp  %o0, 0                                    
 201b4b8:	02 80 00 0e 	be  201b4f0 <rtems_rfs_buffer_handle_request+0xf8>
 201b4bc:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
        rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
 201b4c0:	90 10 20 00 	clr  %o0                                       
 201b4c4:	7f ff e0 91 	call  2013708 <rtems_rfs_trace>                
 201b4c8:	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) &&                 
 201b4cc:	80 8a 20 ff 	btst  0xff, %o0                                
 201b4d0:	22 80 00 09 	be,a   201b4f4 <rtems_rfs_buffer_handle_request+0xfc><== ALWAYS TAKEN
 201b4d4:	c2 07 40 00 	ld  [ %i5 ], %g1                               
        rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
      printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", 
              rtems_rfs_buffer_refs (handle) + 1);                    
 201b4d8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
    handle->buffer = rtems_rfs_scan_chain (&fs->buffers,              
                                           &fs->buffers_count,        
                                           block);                    
    if (rtems_rfs_buffer_handle_has_block (handle) &&                 
        rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
      printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", 
 201b4dc:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b4e0:	d2 00 60 30 	ld  [ %g1 + 0x30 ], %o1                        <== NOT EXECUTED
 201b4e4:	90 12 23 60 	or  %o0, 0x360, %o0                            <== NOT EXECUTED
 201b4e8:	40 00 1a a7 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b4ec:	92 02 60 01 	inc  %o1                                       <== 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) &&                            
 201b4f0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 201b4f4:	80 88 60 02 	btst  2, %g1                                   
 201b4f8:	12 80 00 20 	bne  201b578 <rtems_rfs_buffer_handle_request+0x180>
 201b4fc:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201b500:	80 a0 60 00 	cmp  %g1, 0                                    
 201b504:	32 80 00 42 	bne,a   201b60c <rtems_rfs_buffer_handle_request+0x214>
 201b508:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
      !rtems_rfs_buffer_handle_has_block (handle))                    
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
 201b50c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 201b510:	80 a0 60 00 	cmp  %g1, 0                                    
 201b514:	22 80 00 08 	be,a   201b534 <rtems_rfs_buffer_handle_request+0x13c>
 201b518:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
 201b51c:	90 07 60 54 	add  %i5, 0x54, %o0                            
 201b520:	92 07 60 60 	add  %i5, 0x60, %o1                            
 201b524:	7f ff ff 04 	call  201b134 <rtems_rfs_scan_chain>           
 201b528:	94 10 00 1a 	mov  %i2, %o2                                  
 201b52c:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
 201b530:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201b534:	80 a0 60 00 	cmp  %g1, 0                                    
 201b538:	32 80 00 10 	bne,a   201b578 <rtems_rfs_buffer_handle_request+0x180>
 201b53c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201b540:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
 201b544:	80 a0 60 00 	cmp  %g1, 0                                    
 201b548:	22 80 00 0c 	be,a   201b578 <rtems_rfs_buffer_handle_request+0x180>
 201b54c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
        fs->release_modified_count)                                   
    {                                                                 
      handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,   
 201b550:	90 07 60 64 	add  %i5, 0x64, %o0                            
 201b554:	92 07 60 70 	add  %i5, 0x70, %o1                            
 201b558:	7f ff fe f7 	call  201b134 <rtems_rfs_scan_chain>           
 201b55c:	94 10 00 1a 	mov  %i2, %o2                                  
                                             &fs->release_modified_count,
                                             block);                  
      /*                                                              
       * If we found a buffer retain the dirty buffer state.          
       */                                                             
      if (rtems_rfs_buffer_handle_has_block (handle))                 
 201b560:	80 a2 20 00 	cmp  %o0, 0                                    
 201b564:	02 80 00 04 	be  201b574 <rtems_rfs_buffer_handle_request+0x17c>
 201b568:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
        rtems_rfs_buffer_mark_dirty (handle);                         
 201b56c:	82 10 20 01 	mov  1, %g1                                    
 201b570:	c2 2e 40 00 	stb  %g1, [ %i1 ]                              
  }                                                                   
                                                                      
  /*                                                                  
   * If not located we request the buffer from the I/O layer.         
   */                                                                 
  if (!rtems_rfs_buffer_handle_has_block (handle))                    
 201b574:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201b578:	80 a0 60 00 	cmp  %g1, 0                                    
 201b57c:	32 80 00 24 	bne,a   201b60c <rtems_rfs_buffer_handle_request+0x214>
 201b580:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
  {                                                                   
    rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
 201b584:	90 10 00 1d 	mov  %i5, %o0                                  
 201b588:	92 10 00 1a 	mov  %i2, %o1                                  
 201b58c:	94 10 00 1b 	mov  %i3, %o2                                  
 201b590:	40 00 13 fb 	call  202057c <rtems_rfs_buffer_bdbuf_request> 
 201b594:	96 06 60 08 	add  %i1, 8, %o3                               
                                                                      
    if (rc > 0)                                                       
 201b598:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201b59c:	04 80 00 18 	ble  201b5fc <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
 201b5a0:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))    
 201b5a4:	7f ff e0 59 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b5a8:	92 10 21 00 	mov  0x100, %o1                                <== NOT EXECUTED
 201b5ac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b5b0:	02 80 00 11 	be  201b5f4 <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
 201b5b4:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
        printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
 201b5b8:	22 80 00 05 	be,a   201b5cc <rtems_rfs_buffer_handle_request+0x1d4><== NOT EXECUTED
 201b5bc:	3b 00 80 cd 	sethi  %hi(0x2033400), %i5                     <== NOT EXECUTED
 201b5c0:	3b 00 80 cc 	sethi  %hi(0x2033000), %i5                     <== NOT EXECUTED
 201b5c4:	10 80 00 03 	b  201b5d0 <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
 201b5c8:	ba 17 60 a8 	or  %i5, 0xa8, %i5	! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
 201b5cc:	ba 17 62 f8 	or  %i5, 0x2f8, %i5                            <== NOT EXECUTED
 201b5d0:	40 00 1e d9 	call  2023134 <strerror>                       <== NOT EXECUTED
 201b5d4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201b5d8:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201b5dc:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
 201b5e0:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
 201b5e4:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b5e8:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
 201b5ec:	40 00 1a 66 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b5f0:	90 12 23 98 	or  %o0, 0x398, %o0                            <== NOT EXECUTED
 201b5f4:	81 c7 e0 08 	ret                                            
 201b5f8:	81 e8 00 00 	restore                                        
                block, read ? "read" : "get", rc, strerror (rc));     
      return rc;                                                      
    }                                                                 
                                                                      
    rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));        
 201b5fc:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 201b600:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
 201b604:	c0 20 40 00 	clr  [ %g1 ]                                   
  }                                                                   
                                                                      
  /*                                                                  
   * Increase the reference count of the buffer.                      
   */                                                                 
  rtems_rfs_buffer_refs_up (handle);                                  
 201b608:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
 201b60c:	90 07 60 44 	add  %i5, 0x44, %o0                            
 201b610:	c2 02 60 30 	ld  [ %o1 + 0x30 ], %g1                        
 201b614:	82 00 60 01 	inc  %g1                                       
 201b618:	7f ff c7 cf 	call  200d554 <_Chain_Append>                  
 201b61c:	c2 22 60 30 	st  %g1, [ %o1 + 0x30 ]                        
  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));  
  fs->buffers_count++;                                                
 201b620:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
  handle->bnum = block;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
 201b624:	90 10 20 00 	clr  %o0                                       
  /*                                                                  
   * 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++;                                                
 201b628:	82 00 60 01 	inc  %g1                                       
 201b62c:	c2 27 60 50 	st  %g1, [ %i5 + 0x50 ]                        
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
 201b630:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
  handle->bnum = block;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
 201b634:	92 10 21 00 	mov  0x100, %o1                                
   */                                                                 
  rtems_rfs_buffer_refs_up (handle);                                  
  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));  
  fs->buffers_count++;                                                
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
 201b638:	f4 20 60 34 	st  %i2, [ %g1 + 0x34 ]                        
  handle->bnum = block;                                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
 201b63c:	7f ff e0 33 	call  2013708 <rtems_rfs_trace>                
 201b640:	f4 26 60 04 	st  %i2, [ %i1 + 4 ]                           
 201b644:	80 8a 20 ff 	btst  0xff, %o0                                
 201b648:	02 80 00 0f 	be  201b684 <rtems_rfs_buffer_handle_request+0x28c><== ALWAYS TAKEN
 201b64c:	80 a6 e0 00 	cmp  %i3, 0                                    
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
 201b650:	22 80 00 05 	be,a   201b664 <rtems_rfs_buffer_handle_request+0x26c><== NOT EXECUTED
 201b654:	15 00 80 cd 	sethi  %hi(0x2033400), %o2                     <== NOT EXECUTED
 201b658:	15 00 80 cc 	sethi  %hi(0x2033000), %o2                     <== NOT EXECUTED
 201b65c:	10 80 00 03 	b  201b668 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
 201b660:	94 12 a0 a8 	or  %o2, 0xa8, %o2	! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
 201b664:	94 12 a2 f8 	or  %o2, 0x2f8, %o2                            <== NOT EXECUTED
            block, read ? "read" : "get", handle->buffer->block,      
 201b668:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== 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",
 201b66c:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b670:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
 201b674:	d8 00 60 30 	ld  [ %g1 + 0x30 ], %o4                        <== NOT EXECUTED
 201b678:	90 12 23 d0 	or  %o0, 0x3d0, %o0                            <== NOT EXECUTED
 201b67c:	40 00 1a 42 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b680:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
            block, read ? "read" : "get", handle->buffer->block,      
            handle->buffer->references);                              
                                                                      
  return 0;                                                           
 201b684:	b0 10 20 00 	clr  %i0                                       
}                                                                     
 201b688:	81 c7 e0 08 	ret                                            
 201b68c:	81 e8 00 00 	restore                                        
                                                                      

0201b690 <rtems_rfs_buffer_open>: return rc; } int rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs) {
 201b690:	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))                  
 201b694:	90 10 20 00 	clr  %o0                                       
 201b698:	7f ff e0 1c 	call  2013708 <rtems_rfs_trace>                
 201b69c:	92 10 20 20 	mov  0x20, %o1                                 
 201b6a0:	80 8a 20 ff 	btst  0xff, %o0                                
 201b6a4:	22 80 00 07 	be,a   201b6c0 <rtems_rfs_buffer_open+0x30>    <== ALWAYS TAKEN
 201b6a8:	90 10 00 18 	mov  %i0, %o0                                  
    printf ("rtems-rfs: buffer-open: opening: %s\n", name);           
 201b6ac:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b6b0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 201b6b4:	40 00 1a 34 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b6b8:	90 12 20 10 	or  %o0, 0x10, %o0                             <== NOT EXECUTED
                                                                      
  fs->device = open (name, O_RDWR);                                   
 201b6bc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201b6c0:	7f ff b6 17 	call  2008f1c <open>                           
 201b6c4:	92 10 20 02 	mov  2, %o1                                    
  if (fs->device < 0)                                                 
 201b6c8:	80 a2 20 00 	cmp  %o0, 0                                    
 201b6cc:	16 80 00 0f 	bge  201b708 <rtems_rfs_buffer_open+0x78>      <== ALWAYS TAKEN
 201b6d0:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
 201b6d4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201b6d8:	7f ff e0 0c 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b6dc:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
 201b6e0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b6e4:	12 80 00 04 	bne  201b6f4 <rtems_rfs_buffer_open+0x64>      <== NOT EXECUTED
 201b6e8:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: cannot open file\n");          
    return ENXIO;                                                     
 201b6ec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b6f0:	91 e8 20 06 	restore  %g0, 6, %o0                           <== 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");          
 201b6f4:	90 12 20 38 	or  %o0, 0x38, %o0                             <== NOT EXECUTED
 201b6f8:	40 00 1a bb 	call  20221e4 <puts>                           <== NOT EXECUTED
 201b6fc:	01 00 00 00 	nop                                            <== NOT EXECUTED
    return ENXIO;                                                     
 201b700:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b704:	91 e8 20 06 	restore  %g0, 6, %o0                           <== NOT EXECUTED
  }                                                                   
                                                                      
  if (fstat (fs->device, &st) < 0)                                    
 201b708:	7f ff b2 61 	call  200808c <fstat>                          
 201b70c:	92 07 bf b8 	add  %fp, -72, %o1                             
 201b710:	80 a2 20 00 	cmp  %o0, 0                                    
 201b714:	16 80 00 12 	bge  201b75c <rtems_rfs_buffer_open+0xcc>      <== ALWAYS TAKEN
 201b718:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
 201b71c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201b720:	7f ff df fa 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b724:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
 201b728:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b72c:	02 bf ff f5 	be  201b700 <rtems_rfs_buffer_open+0x70>       <== NOT EXECUTED
 201b730:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",       
              name, strerror (errno));                                
 201b734:	40 00 14 bb 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201b738:	01 00 00 00 	nop                                            <== 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",       
 201b73c:	40 00 1e 7e 	call  2023134 <strerror>                       <== NOT EXECUTED
 201b740:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 201b744:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 201b748:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201b74c:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b750:	40 00 1a 0d 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b754:	90 12 20 68 	or  %o0, 0x68, %o0	! 2033868 <CSWTCH.2+0x388>  <== NOT EXECUTED
 201b758:	30 bf ff ea 	b,a   201b700 <rtems_rfs_buffer_open+0x70>     <== NOT EXECUTED
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  /*                                                                  
   * Is the device a block device ?                                   
   */                                                                 
  if (!S_ISBLK (st.st_mode))                                          
 201b75c:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 201b760:	84 08 80 01 	and  %g2, %g1, %g2                             
 201b764:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
 201b768:	80 a0 80 01 	cmp  %g2, %g1                                  
 201b76c:	22 80 00 0c 	be,a   201b79c <rtems_rfs_buffer_open+0x10c>   <== ALWAYS TAKEN
 201b770:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
 201b774:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201b778:	7f ff df e4 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b77c:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
 201b780:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b784:	02 bf ff df 	be  201b700 <rtems_rfs_buffer_open+0x70>       <== NOT EXECUTED
 201b788:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
 201b78c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 201b790:	40 00 19 fd 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b794:	90 12 20 98 	or  %o0, 0x98, %o0                             <== NOT EXECUTED
 201b798:	30 bf ff da 	b,a   201b700 <rtems_rfs_buffer_open+0x70>     <== 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);                   
 201b79c:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
 201b7a0:	94 06 60 10 	add  %i1, 0x10, %o2                            
 201b7a4:	7f ff b2 8d 	call  20081d8 <ioctl>                          
 201b7a8:	92 12 62 09 	or  %o1, 0x209, %o1                            
                                                                      
  /*                                                                  
   * 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)                                                        
 201b7ac:	80 a2 20 00 	cmp  %o0, 0                                    
 201b7b0:	02 80 00 09 	be  201b7d4 <rtems_rfs_buffer_open+0x144>      <== ALWAYS TAKEN
 201b7b4:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
 201b7b8:	7f ff df d4 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b7bc:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
 201b7c0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b7c4:	02 bf ff cf 	be  201b700 <rtems_rfs_buffer_open+0x70>       <== NOT EXECUTED
 201b7c8:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");    
 201b7cc:	10 bf ff cb 	b  201b6f8 <rtems_rfs_buffer_open+0x68>        <== NOT EXECUTED
 201b7d0:	90 12 20 d0 	or  %o0, 0xd0, %o0	! 20338d0 <CSWTCH.2+0x3f0>  <== NOT EXECUTED
#else                                                                 
  fs->media_size = st.st_size;                                        
  strcat (fs->name, name);                                            
#endif                                                                
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                  
 201b7d4:	92 10 20 20 	mov  0x20, %o1                                 
 201b7d8:	7f ff df cc 	call  2013708 <rtems_rfs_trace>                
 201b7dc:	b0 10 20 00 	clr  %i0                                       
 201b7e0:	80 8a 20 ff 	btst  0xff, %o0                                
 201b7e4:	02 80 00 07 	be  201b800 <rtems_rfs_buffer_open+0x170>      <== ALWAYS TAKEN
 201b7e8:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     
    printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
            rtems_rfs_fs_media_blocks (fs),                           
 201b7ec:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        <== NOT EXECUTED
  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",
 201b7f0:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
 201b7f4:	d4 00 60 20 	ld  [ %g1 + 0x20 ], %o2                        <== NOT EXECUTED
 201b7f8:	40 00 19 e3 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b7fc:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_media_blocks (fs),                           
            rtems_rfs_fs_media_block_size (fs));                      
                                                                      
  return 0;                                                           
}                                                                     
 201b800:	81 c7 e0 08 	ret                                            
 201b804:	81 e8 00 00 	restore                                        
                                                                      

0201b910 <rtems_rfs_buffer_setblksize>: return result; } int rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size) {
 201b910:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
 201b914:	90 10 20 00 	clr  %o0                                       
  return result;                                                      
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)  
{                                                                     
 201b918:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
 201b91c:	7f ff df 7b 	call  2013708 <rtems_rfs_trace>                
 201b920:	92 10 24 00 	mov  0x400, %o1                                
 201b924:	80 8a 20 ff 	btst  0xff, %o0                                
 201b928:	02 80 00 05 	be  201b93c <rtems_rfs_buffer_setblksize+0x2c> <== ALWAYS TAKEN
 201b92c:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
    printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size); 
 201b930:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b934:	40 00 19 94 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b938:	90 12 21 d0 	or  %o0, 0x1d0, %o0	! 20339d0 <CSWTCH.2+0x4f0> <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffers_release (fs);                                
 201b93c:	7f ff ff d5 	call  201b890 <rtems_rfs_buffers_release>      
 201b940:	90 10 00 18 	mov  %i0, %o0                                  
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
 201b944:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201b948:	04 80 00 0e 	ble  201b980 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
 201b94c:	90 10 20 00 	clr  %o0                                       
 201b950:	7f ff df 6e 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b954:	92 10 24 00 	mov  0x400, %o1                                <== NOT EXECUTED
 201b958:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b95c:	02 80 00 09 	be  201b980 <rtems_rfs_buffer_setblksize+0x70> <== NOT EXECUTED
 201b960:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
 201b964:	40 00 1d f4 	call  2023134 <strerror>                       <== NOT EXECUTED
 201b968:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201b96c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201b970:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201b974:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b978:	40 00 19 83 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b97c:	90 12 22 00 	or  %o0, 0x200, %o0	! 2033a00 <CSWTCH.2+0x520> <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_buffer_sync (fs);                                    
 201b980:	7f ff ff a2 	call  201b808 <rtems_rfs_buffer_sync>          
 201b984:	90 10 00 18 	mov  %i0, %o0                                  
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
 201b988:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201b98c:	04 80 00 0e 	ble  201b9c4 <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
 201b990:	90 10 20 00 	clr  %o0                                       
 201b994:	7f ff df 5d 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b998:	92 10 24 00 	mov  0x400, %o1                                <== NOT EXECUTED
 201b99c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b9a0:	22 80 00 0a 	be,a   201b9c8 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
 201b9a4:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
    printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
 201b9a8:	40 00 1d e3 	call  2023134 <strerror>                       <== NOT EXECUTED
 201b9ac:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201b9b0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201b9b4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201b9b8:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b9bc:	40 00 19 72 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b9c0:	90 12 22 40 	or  %o0, 0x240, %o0	! 2033a40 <CSWTCH.2+0x560> <== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);     
 201b9c4:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
 201b9c8:	13 20 01 10 	sethi  %hi(0x80044000), %o1                    
 201b9cc:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 201b9d0:	92 12 62 04 	or  %o1, 0x204, %o1                            
 201b9d4:	9f c0 40 00 	call  %g1                                      
 201b9d8:	94 07 a0 48 	add  %fp, 0x48, %o2                            
  if (rc < 0)                                                         
 201b9dc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201b9e0:	16 80 00 05 	bge  201b9f4 <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
 201b9e4:	01 00 00 00 	nop                                            
    rc = errno;                                                       
 201b9e8:	40 00 14 0e 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201b9ec:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201b9f0:	f0 02 00 00 	ld  [ %o0 ], %i0                               <== NOT EXECUTED
#endif                                                                
  return rc;                                                          
}                                                                     
 201b9f4:	81 c7 e0 08 	ret                                            
 201b9f8:	81 e8 00 00 	restore                                        
                                                                      

0201b808 <rtems_rfs_buffer_sync>: return rc; } int rtems_rfs_buffer_sync (rtems_rfs_file_system* fs) {
 201b808:	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))                  
 201b80c:	90 10 20 00 	clr  %o0                                       
 201b810:	7f ff df be 	call  2013708 <rtems_rfs_trace>                
 201b814:	92 10 20 20 	mov  0x20, %o1                                 
 201b818:	80 8a 20 ff 	btst  0xff, %o0                                
 201b81c:	22 80 00 06 	be,a   201b834 <rtems_rfs_buffer_sync+0x2c>    <== ALWAYS TAKEN
 201b820:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
    printf ("rtems-rfs: buffer-sync: syncing\n");                     
 201b824:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b828:	40 00 1a 6f 	call  20221e4 <puts>                           <== NOT EXECUTED
 201b82c:	90 12 21 30 	or  %o0, 0x130, %o0	! 2033930 <CSWTCH.2+0x450> <== 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));                
 201b830:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
 201b834:	7f ff e9 1c 	call  2015ca4 <rtems_bdbuf_syncdev>            
 201b838:	ba 10 20 00 	clr  %i5                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 201b83c:	80 a2 20 00 	cmp  %o0, 0                                    
 201b840:	02 80 00 0f 	be  201b87c <rtems_rfs_buffer_sync+0x74>       <== ALWAYS TAKEN
 201b844:	b8 10 00 08 	mov  %o0, %i4                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))                
 201b848:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201b84c:	92 10 20 20 	mov  0x20, %o1                                 <== NOT EXECUTED
 201b850:	7f ff df ae 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201b854:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
 201b858:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201b85c:	22 80 00 09 	be,a   201b880 <rtems_rfs_buffer_sync+0x78>    <== NOT EXECUTED
 201b860:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
      printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",     
 201b864:	7f ff b1 44 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201b868:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201b86c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 201b870:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b874:	40 00 19 c4 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b878:	90 12 21 50 	or  %o0, 0x150, %o0	! 2033950 <CSWTCH.2+0x470> <== NOT EXECUTED
              rtems_status_text (sc));                                
    result = EIO;                                                     
  }                                                                   
  rtems_disk_release (fs->disk);                                      
 201b87c:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
 201b880:	7f ff a3 ec 	call  2004830 <rtems_disk_release>             
 201b884:	b0 10 00 1d 	mov  %i5, %i0                                  
      printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",   
              result, strerror (result));                             
  }                                                                   
#endif                                                                
  return result;                                                      
}                                                                     
 201b888:	81 c7 e0 08 	ret                                            
 201b88c:	81 e8 00 00 	restore                                        
                                                                      

0201b890 <rtems_rfs_buffers_release>: return rrc; } int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) {
 201b890:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rrc = 0;                                                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
 201b894:	90 10 20 00 	clr  %o0                                       
 201b898:	92 10 20 40 	mov  0x40, %o1                                 
 201b89c:	7f ff df 9b 	call  2013708 <rtems_rfs_trace>                
 201b8a0:	ba 10 00 18 	mov  %i0, %i5                                  
 201b8a4:	80 8a 20 ff 	btst  0xff, %o0                                
 201b8a8:	02 80 00 09 	be  201b8cc <rtems_rfs_buffers_release+0x3c>   <== ALWAYS TAKEN
 201b8ac:	92 07 60 60 	add  %i5, 0x60, %o1                            
    printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "         
 201b8b0:	d2 06 20 50 	ld  [ %i0 + 0x50 ], %o1                        <== NOT EXECUTED
 201b8b4:	d4 06 20 60 	ld  [ %i0 + 0x60 ], %o2                        <== NOT EXECUTED
 201b8b8:	d6 06 20 70 	ld  [ %i0 + 0x70 ], %o3                        <== NOT EXECUTED
 201b8bc:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201b8c0:	40 00 19 b1 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b8c4:	90 12 21 80 	or  %o0, 0x180, %o0	! 2033980 <CSWTCH.2+0x4a0> <== 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,                         
 201b8c8:	92 07 60 60 	add  %i5, 0x60, %o1                            <== NOT EXECUTED
 201b8cc:	94 10 20 00 	clr  %o2                                       
 201b8d0:	7f ff fd f6 	call  201b0a8 <rtems_rfs_release_chain>        
 201b8d4:	90 07 60 54 	add  %i5, 0x54, %o0                            
 201b8d8:	82 38 00 08 	xnor  %g0, %o0, %g1                            
 201b8dc:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
                                &fs->release_count,                   
                                false);                               
  if ((rc > 0) && (rrc == 0))                                         
    rrc = rc;                                                         
  rc = rtems_rfs_release_chain (&fs->release_modified,                
 201b8e0:	92 07 60 70 	add  %i5, 0x70, %o1                            
 201b8e4:	b0 0a 00 01 	and  %o0, %g1, %i0                             
 201b8e8:	94 10 20 01 	mov  1, %o2                                    
 201b8ec:	7f ff fd ef 	call  201b0a8 <rtems_rfs_release_chain>        
 201b8f0:	90 07 60 64 	add  %i5, 0x64, %o0                            
                                &fs->release_modified_count,          
                                true);                                
  if ((rc > 0) && (rrc == 0))                                         
 201b8f4:	80 a6 20 00 	cmp  %i0, 0                                    
 201b8f8:	12 80 00 04 	bne  201b908 <rtems_rfs_buffers_release+0x78>  <== NEVER TAKEN
 201b8fc:	80 a2 20 00 	cmp  %o0, 0                                    
 201b900:	34 80 00 02 	bg,a   201b908 <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
 201b904:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    rrc = rc;                                                         
                                                                      
  return rrc;                                                         
}                                                                     
 201b908:	81 c7 e0 08 	ret                                            
 201b90c:	81 e8 00 00 	restore                                        
                                                                      

0201bfec <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) {
 201bfec:	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))                
 201bff0:	90 10 20 00 	clr  %o0                                       
 201bff4:	7f ff dd c5 	call  2013708 <rtems_rfs_trace>                
 201bff8:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    
 201bffc:	80 8a 20 ff 	btst  0xff, %o0                                
 201c000:	02 80 00 14 	be  201c050 <rtems_rfs_dir_add_entry+0x64>     <== ALWAYS TAKEN
 201c004:	a6 07 bf b0 	add  %fp, -80, %l3                             
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",       
 201c008:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201c00c:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c010:	ba 10 00 1a 	mov  %i2, %i5                                  <== NOT EXECUTED
 201c014:	90 12 21 f0 	or  %o0, 0x1f0, %o0                            <== NOT EXECUTED
 201c018:	40 00 17 db 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c01c:	a0 06 80 1b 	add  %i2, %i3, %l0                             <== NOT EXECUTED
            rtems_rfs_inode_ino (dir));                               
    for (c = 0; c < length; c++)                                      
 201c020:	10 80 00 05 	b  201c034 <rtems_rfs_dir_add_entry+0x48>      <== NOT EXECUTED
 201c024:	80 a7 40 10 	cmp  %i5, %l0                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
 201c028:	40 00 18 41 	call  202212c <putchar>                        <== NOT EXECUTED
 201c02c:	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++)                                      
 201c030:	80 a7 40 10 	cmp  %i5, %l0                                  <== NOT EXECUTED
 201c034:	32 bf ff fd 	bne,a   201c028 <rtems_rfs_dir_add_entry+0x3c> <== NOT EXECUTED
 201c038:	d0 4f 40 00 	ldsb  [ %i5 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%zd\n", length);                                   
 201c03c:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c040:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201c044:	40 00 17 d0 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c048:	90 12 22 20 	or  %o0, 0x220, %o0                            <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
 201c04c:	a6 07 bf b0 	add  %fp, -80, %l3                             <== NOT EXECUTED
 201c050:	90 10 00 18 	mov  %i0, %o0                                  
 201c054:	92 10 00 19 	mov  %i1, %o1                                  
 201c058:	7f ff f8 fb 	call  201a444 <rtems_rfs_block_map_open>       
 201c05c:	94 10 00 13 	mov  %l3, %o2                                  
  if (rc > 0)                                                         
 201c060:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201c064:	34 80 00 c5 	bg,a   201c378 <rtems_rfs_dir_add_entry+0x38c> <== NEVER TAKEN
 201c068:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201c06c:	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;                                              
 201c070:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
 201c074:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
 201c078:	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;                                                      
 201c07c:	c0 27 bf 98 	clr  [ %fp + -104 ]                            
  bpos->boff = 0;                                                     
 201c080:	c0 27 bf 9c 	clr  [ %fp + -100 ]                            
  bpos->block = 0;                                                    
 201c084:	c0 27 bf a0 	clr  [ %fp + -96 ]                             
 201c088:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
 201c08c:	aa 06 e0 0a 	add  %i3, 0xa, %l5                             
    /*                                                                
     * 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);          
 201c090:	90 10 00 18 	mov  %i0, %o0                                  
 201c094:	92 10 00 13 	mov  %l3, %o1                                  
 201c098:	94 07 bf 98 	add  %fp, -104, %o2                            
 201c09c:	7f ff f9 bf 	call  201a798 <rtems_rfs_block_map_find>       
 201c0a0:	96 07 bf 94 	add  %fp, -108, %o3                            
    if (rc > 0)                                                       
 201c0a4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201c0a8:	04 80 00 29 	ble  201c14c <rtems_rfs_dir_add_entry+0x160>   
 201c0ac:	80 a7 60 06 	cmp  %i5, 6                                    
    {                                                                 
      if (rc != ENXIO)                                                
 201c0b0:	02 80 00 0f 	be  201c0ec <rtems_rfs_dir_add_entry+0x100>    <== ALWAYS TAKEN
 201c0b4:	90 10 00 18 	mov  %i0, %o0                                  
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
 201c0b8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c0bc:	7f ff dd 93 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c0c0:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
 201c0c4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c0c8:	22 80 00 a6 	be,a   201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
 201c0cc:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
 201c0d0:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
 201c0d4:	40 00 1c 18 	call  2023134 <strerror>                       <== NOT EXECUTED
 201c0d8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c0dc:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201c0e0:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c0e4:	10 80 00 15 	b  201c138 <rtems_rfs_dir_add_entry+0x14c>     <== NOT EXECUTED
 201c0e8:	90 12 22 30 	or  %o0, 0x230, %o0	! 2033e30 <CSWTCH.2+0x950> <== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       * We have reached the end of the directory so add a block.     
       */                                                             
      rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);            
 201c0ec:	92 10 00 13 	mov  %l3, %o1                                  
 201c0f0:	94 10 20 01 	mov  1, %o2                                    
 201c0f4:	7f ff fa 2f 	call  201a9b0 <rtems_rfs_block_map_grow>       
 201c0f8:	96 07 bf 94 	add  %fp, -108, %o3                            
      if (rc > 0)                                                     
 201c0fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201c100:	04 80 00 14 	ble  201c150 <rtems_rfs_dir_add_entry+0x164>   <== ALWAYS TAKEN
 201c104:	a0 10 20 00 	clr  %l0                                       
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
 201c108:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c10c:	7f ff dd 7f 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c110:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
 201c114:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c118:	22 80 00 92 	be,a   201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
 201c11c:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
 201c120:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
 201c124:	40 00 1c 04 	call  2023134 <strerror>                       <== NOT EXECUTED
 201c128:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c12c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201c130:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c134:	90 12 22 78 	or  %o0, 0x278, %o0	! 2033e78 <CSWTCH.2+0x998> <== NOT EXECUTED
 201c138:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201c13c:	40 00 17 92 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c140:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
      entry  += elength;                                              
      offset += elength;                                              
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201c144:	10 80 00 87 	b  201c360 <rtems_rfs_dir_add_entry+0x374>     <== NOT EXECUTED
 201c148:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
 201c14c:	a0 10 20 01 	mov  1, %l0                                    
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
 201c150:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
 201c154:	d4 07 bf 94 	ld  [ %fp + -108 ], %o2                        
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
 201c158:	82 00 60 01 	inc  %g1                                       
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
 201c15c:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
 201c160:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
 201c164:	90 10 00 18 	mov  %i0, %o0                                  
 201c168:	92 07 bf a4 	add  %fp, -92, %o1                             
 201c16c:	7f ff fc a3 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201c170:	96 10 00 10 	mov  %l0, %o3                                  
    if (rc > 0)                                                       
 201c174:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201c178:	04 80 00 0f 	ble  201c1b4 <rtems_rfs_dir_add_entry+0x1c8>   <== ALWAYS TAKEN
 201c17c:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))            
 201c180:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c184:	7f ff dd 61 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c188:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
 201c18c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c190:	22 80 00 74 	be,a   201c360 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
 201c194:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-add-entry: "                          
 201c198:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
 201c19c:	40 00 1b e6 	call  2023134 <strerror>                       <== NOT EXECUTED
 201c1a0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c1a4:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201c1a8:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c1ac:	10 bf ff e3 	b  201c138 <rtems_rfs_dir_add_entry+0x14c>     <== NOT EXECUTED
 201c1b0:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 2033ec0 <CSWTCH.2+0x9e0> <== NOT EXECUTED
      break;                                                          
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
                                                                      
    if (!read)                                                        
 201c1b4:	80 a4 20 00 	cmp  %l0, 0                                    
 201c1b8:	12 80 00 06 	bne  201c1d0 <rtems_rfs_dir_add_entry+0x1e4>   
 201c1bc:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        
      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));             
 201c1c0:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           
 201c1c4:	90 10 00 1d 	mov  %i5, %o0                                  
 201c1c8:	40 00 16 f1 	call  2021d8c <memset>                         
 201c1cc:	92 10 20 ff 	mov  0xff, %o1                                 
                                                                      
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201c1d0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
    entry  = rtems_rfs_buffer_data (&buffer);                         
                                                                      
    if (!read)                                                        
      memset (entry, 0xff, rtems_rfs_fs_block_size (fs));             
                                                                      
    offset = 0;                                                       
 201c1d4:	a2 10 20 00 	clr  %l1                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201c1d8:	10 80 00 5d 	b  201c34c <rtems_rfs_dir_add_entry+0x360>     
 201c1dc:	84 00 7f f6 	add  %g1, -10, %g2                             
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
 201c1e0:	e0 0f 60 08 	ldub  [ %i5 + 8 ], %l0                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201c1e4:	e4 0f 40 00 	ldub  [ %i5 ], %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);                   
 201c1e8:	a1 2c 20 08 	sll  %l0, 8, %l0                               
 201c1ec:	a0 14 00 03 	or  %l0, %g3, %l0                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201c1f0:	c6 0f 60 01 	ldub  [ %i5 + 1 ], %g3                         
 201c1f4:	a5 2c a0 18 	sll  %l2, 0x18, %l2                            
 201c1f8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 201c1fc:	a4 14 80 03 	or  %l2, %g3, %l2                              
 201c200:	c6 0f 60 03 	ldub  [ %i5 + 3 ], %g3                         
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201c204:	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);                      
 201c208:	a4 14 80 03 	or  %l2, %g3, %l2                              
 201c20c:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
 201c210:	87 28 e0 08 	sll  %g3, 8, %g3                               
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201c214:	12 80 00 2a 	bne  201c2bc <rtems_rfs_dir_add_entry+0x2d0>   
 201c218:	a4 14 80 03 	or  %l2, %g3, %l2                              
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
            (rtems_rfs_fs_block_size (fs) - offset))                  
 201c21c:	a2 20 40 11 	sub  %g1, %l1, %l1                             
      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) <                     
 201c220:	80 a5 40 11 	cmp  %l5, %l1                                  
 201c224:	3a bf ff 9c 	bcc,a   201c094 <rtems_rfs_dir_add_entry+0xa8> <== NEVER TAKEN
 201c228:	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);                   
 201c22c:	92 10 00 1b 	mov  %i3, %o1                                  
 201c230:	40 00 11 10 	call  2020670 <rtems_rfs_dir_hash>             
 201c234:	90 10 00 1a 	mov  %i2, %o0                                  
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
 201c238:	83 32 20 18 	srl  %o0, 0x18, %g1                            
 201c23c:	c2 2f 60 04 	stb  %g1, [ %i5 + 4 ]                          
 201c240:	83 32 20 10 	srl  %o0, 0x10, %g1                            
 201c244:	c2 2f 60 05 	stb  %g1, [ %i5 + 5 ]                          
 201c248:	83 32 20 08 	srl  %o0, 8, %g1                               
 201c24c:	c2 2f 60 06 	stb  %g1, [ %i5 + 6 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
 201c250:	83 37 20 18 	srl  %i4, 0x18, %g1                            
 201c254:	c2 2f 40 00 	stb  %g1, [ %i5 ]                              
 201c258:	83 37 20 10 	srl  %i4, 0x10, %g1                            
 201c25c:	c2 2f 60 01 	stb  %g1, [ %i5 + 1 ]                          
 201c260:	83 37 20 08 	srl  %i4, 8, %g1                               
 201c264:	c2 2f 60 02 	stb  %g1, [ %i5 + 2 ]                          
          rtems_rfs_dir_set_entry_length (entry,                      
 201c268:	82 06 e0 0a 	add  %i3, 0xa, %g1                             
 201c26c:	85 30 60 08 	srl  %g1, 8, %g2                               
        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);                 
 201c270:	d0 2f 60 07 	stb  %o0, [ %i5 + 7 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
          rtems_rfs_dir_set_entry_length (entry,                      
 201c274:	c4 2f 60 08 	stb  %g2, [ %i5 + 8 ]                          
 201c278:	c2 2f 60 09 	stb  %g1, [ %i5 + 9 ]                          
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
 201c27c:	94 10 00 1b 	mov  %i3, %o2                                  
            (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);                 
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
 201c280:	f8 2f 60 03 	stb  %i4, [ %i5 + 3 ]                          
          rtems_rfs_dir_set_entry_length (entry,                      
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
 201c284:	90 07 60 0a 	add  %i5, 0xa, %o0                             
 201c288:	40 00 16 32 	call  2021b50 <memcpy>                         
 201c28c:	92 10 00 1a 	mov  %i2, %o1                                  
          rtems_rfs_buffer_mark_dirty (&buffer);                      
 201c290:	82 10 20 01 	mov  1, %g1                                    
          rtems_rfs_buffer_handle_close (fs, &buffer);                
 201c294:	92 07 bf a4 	add  %fp, -92, %o1                             
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
          rtems_rfs_dir_set_entry_length (entry,                      
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
          rtems_rfs_buffer_mark_dirty (&buffer);                      
 201c298:	c2 2f bf a4 	stb  %g1, [ %fp + -92 ]                        
          rtems_rfs_buffer_handle_close (fs, &buffer);                
 201c29c:	7f ff fe 0c 	call  201bacc <rtems_rfs_buffer_handle_close>  
 201c2a0:	90 10 00 18 	mov  %i0, %o0                                  
          rtems_rfs_block_map_close (fs, &map);                       
 201c2a4:	90 10 00 18 	mov  %i0, %o0                                  
 201c2a8:	92 07 bf b0 	add  %fp, -80, %o1                             
 201c2ac:	7f ff f8 c7 	call  201a5c8 <rtems_rfs_block_map_close>      
 201c2b0:	ba 10 20 00 	clr  %i5                                       
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
 201c2b4:	81 c7 e0 08 	ret                                            
 201c2b8:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
        }                                                             
                                                                      
        break;                                                        
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
 201c2bc:	80 a4 20 0a 	cmp  %l0, 0xa                                  
 201c2c0:	04 80 00 0d 	ble  201c2f4 <rtems_rfs_dir_add_entry+0x308>   <== NEVER TAKEN
 201c2c4:	90 10 20 00 	clr  %o0                                       
 201c2c8:	c6 06 20 1c 	ld  [ %i0 + 0x1c ], %g3                        
 201c2cc:	80 a4 00 03 	cmp  %l0, %g3                                  
 201c2d0:	1a 80 00 09 	bcc  201c2f4 <rtems_rfs_dir_add_entry+0x308>   <== NEVER TAKEN
 201c2d4:	80 a4 a0 00 	cmp  %l2, 0                                    
 201c2d8:	02 80 00 07 	be  201c2f4 <rtems_rfs_dir_add_entry+0x308>    <== NEVER TAKEN
 201c2dc:	01 00 00 00 	nop                                            
 201c2e0:	c6 06 20 14 	ld  [ %i0 + 0x14 ], %g3                        
 201c2e4:	80 a4 80 03 	cmp  %l2, %g3                                  
 201c2e8:	28 80 00 18 	bleu,a   201c348 <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
 201c2ec:	ba 07 40 10 	add  %i5, %l0, %i5                             
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
 201c2f0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c2f4:	7f ff dd 05 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c2f8:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
 201c2fc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c300:	02 80 00 0a 	be  201c328 <rtems_rfs_dir_add_entry+0x33c>    <== NOT EXECUTED
 201c304:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
 201c308:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201c30c:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c310:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 201c314:	90 12 23 08 	or  %o0, 0x308, %o0                            <== NOT EXECUTED
 201c318:	96 10 00 12 	mov  %l2, %o3                                  <== NOT EXECUTED
 201c31c:	40 00 17 1a 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c320:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
                  "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);                  
 201c324:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
 201c328:	7f ff fd e9 	call  201bacc <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201c32c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
        rtems_rfs_block_map_close (fs, &map);                         
 201c330:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201c334:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
 201c338:	7f ff f8 a4 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201c33c:	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;                                                          
}                                                                     
 201c340:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201c344:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
        rtems_rfs_block_map_close (fs, &map);                         
        return EIO;                                                   
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
 201c348:	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))
 201c34c:	80 a4 40 02 	cmp  %l1, %g2                                  
 201c350:	2a bf ff a4 	bcs,a   201c1e0 <rtems_rfs_dir_add_entry+0x1f4><== ALWAYS TAKEN
 201c354:	c6 0f 60 09 	ldub  [ %i5 + 9 ], %g3                         
    /*                                                                
     * 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);          
 201c358:	10 bf ff 4f 	b  201c094 <rtems_rfs_dir_add_entry+0xa8>      <== NOT EXECUTED
 201c35c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      entry  += elength;                                              
      offset += elength;                                              
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201c360:	7f ff fd db 	call  201bacc <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201c364:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
 201c368:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201c36c:	7f ff f8 97 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201c370:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
  return rc;                                                          
}                                                                     
 201c374:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 201c378:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201c37c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201c380 <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) {
 201c380:	9d e3 bf 38 	save  %sp, -200, %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))                
 201c384:	90 10 20 00 	clr  %o0                                       
 201c388:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    
 201c38c:	7f ff dc df 	call  2013708 <rtems_rfs_trace>                
 201c390:	ba 10 00 18 	mov  %i0, %i5                                  
 201c394:	80 8a 20 ff 	btst  0xff, %o0                                
 201c398:	02 80 00 09 	be  201c3bc <rtems_rfs_dir_del_entry+0x3c>     <== ALWAYS TAKEN
 201c39c:	aa 07 bf b0 	add  %fp, -80, %l5                             
    printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
 201c3a0:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201c3a4:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c3a8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 201c3ac:	90 12 23 50 	or  %o0, 0x350, %o0                            <== NOT EXECUTED
 201c3b0:	40 00 16 f5 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c3b4:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
            rtems_rfs_inode_ino (dir), ino, offset);                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
 201c3b8:	aa 07 bf b0 	add  %fp, -80, %l5                             <== NOT EXECUTED
 201c3bc:	90 10 00 1d 	mov  %i5, %o0                                  
 201c3c0:	92 10 00 19 	mov  %i1, %o1                                  
 201c3c4:	7f ff f8 20 	call  201a444 <rtems_rfs_block_map_open>       
 201c3c8:	94 10 00 15 	mov  %l5, %o2                                  
  if (rc > 0)                                                         
 201c3cc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201c3d0:	14 80 00 c4 	bg  201c6e0 <rtems_rfs_dir_del_entry+0x360>    <== NEVER TAKEN
 201c3d4:	ac 07 bf a0 	add  %fp, -96, %l6                             
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
 201c3d8:	90 10 00 1d 	mov  %i5, %o0                                  
 201c3dc:	92 10 00 15 	mov  %l5, %o1                                  
 201c3e0:	94 10 20 00 	clr  %o2                                       
 201c3e4:	96 10 00 1b 	mov  %i3, %o3                                  
 201c3e8:	7f ff f9 48 	call  201a908 <rtems_rfs_block_map_seek>       
 201c3ec:	98 10 00 16 	mov  %l6, %o4                                  
  if (rc > 0)                                                         
 201c3f0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201c3f4:	04 80 00 06 	ble  201c40c <rtems_rfs_dir_del_entry+0x8c>    <== ALWAYS TAKEN
 201c3f8:	80 a6 20 06 	cmp  %i0, 6                                    
  {                                                                   
    if (rc == ENXIO)                                                  
 201c3fc:	22 80 00 b6 	be,a   201c6d4 <rtems_rfs_dir_del_entry+0x354> <== NOT EXECUTED
 201c400:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
          }                                                           
        }                                                             
                                                                      
        rtems_rfs_buffer_mark_dirty (&buffer);                        
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
 201c404:	10 80 00 b5 	b  201c6d8 <rtems_rfs_dir_del_entry+0x358>     <== NOT EXECUTED
 201c408:	90 10 00 1d 	mov  %i5, %o0                                  <== 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)                                                       
 201c40c:	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)                       
 201c410:	29 00 00 3f 	sethi  %hi(0xfc00), %l4                        
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
          printf ("rtems-rfs: dir-del-entry: "                        
 201c414:	2f 00 80 cf 	sethi  %hi(0x2033c00), %l7                     
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201c418:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
 201c41c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
 201c420:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &buffer);                    
 201c424:	b0 10 20 00 	clr  %i0                                       
                                                                      
    /*                                                                
     * If we are searching start at the beginning of the block. If not searching
     * skip to the offset in the block.                               
     */                                                               
    if (search)                                                       
 201c428:	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)                       
 201c42c:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
  /*                                                                  
   * Only search if the offset is 0 else we are at that position.     
   */                                                                 
  search = offset ? false : true;                                     
                                                                      
  while (rc == 0)                                                     
 201c430:	10 80 00 c1 	b  201c734 <rtems_rfs_dir_del_entry+0x3b4>     
 201c434:	ae 15 e3 d8 	or  %l7, 0x3d8, %l7                            
  {                                                                   
    uint8_t* entry;                                                   
    int      eoffset;                                                 
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
 201c438:	90 10 00 1d 	mov  %i5, %o0                                  
 201c43c:	92 07 bf a4 	add  %fp, -92, %o1                             
 201c440:	7f ff fb ee 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201c444:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
 201c448:	a4 92 20 00 	orcc  %o0, 0, %l2                              
 201c44c:	04 80 00 13 	ble  201c498 <rtems_rfs_dir_del_entry+0x118>   <== ALWAYS TAKEN
 201c450:	80 a4 e0 00 	cmp  %l3, 0                                    
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))            
 201c454:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c458:	7f ff dc ac 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c45c:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
 201c460:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c464:	22 80 00 b9 	be,a   201c748 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
 201c468:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-del-entry: "                          
 201c46c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
 201c470:	40 00 1b 31 	call  2023134 <strerror>                       <== NOT EXECUTED
 201c474:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
 201c478:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201c47c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201c480:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
 201c484:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201c488:	40 00 16 bf 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c48c:	90 12 23 90 	or  %o0, 0x390, %o0	! 2033f90 <CSWTCH.2+0xab0> <== NOT EXECUTED
      if (rc == ENXIO)                                                
        rc = ENOENT;                                                  
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201c490:	10 80 00 ae 	b  201c748 <rtems_rfs_dir_del_entry+0x3c8>     <== NOT EXECUTED
 201c494:	92 07 bf a4 	add  %fp, -92, %o1                             <== 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)                                                       
 201c498:	12 80 00 06 	bne  201c4b0 <rtems_rfs_dir_del_entry+0x130>   <== NEVER TAKEN
 201c49c:	a0 10 20 00 	clr  %l0                                       
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
 201c4a0:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
 201c4a4:	40 00 47 39 	call  202e188 <.urem>                          
 201c4a8:	90 10 00 1b 	mov  %i3, %o0                                  
 201c4ac:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
 201c4b0:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
 201c4b4:	f8 00 60 1c 	ld  [ %g1 + 0x1c ], %i4                        
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201c4b8:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    if (search)                                                       
      eoffset = 0;                                                    
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
 201c4bc:	b8 07 00 10 	add  %i4, %l0, %i4                             
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201c4c0:	10 80 00 8d 	b  201c6f4 <rtems_rfs_dir_del_entry+0x374>     
 201c4c4:	84 00 7f f6 	add  %g1, -10, %g2                             
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
 201c4c8:	e2 0f 20 08 	ldub  [ %i4 + 8 ], %l1                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201c4cc:	d6 0f 00 00 	ldub  [ %i4 ], %o3                             
    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);                   
 201c4d0:	a3 2c 60 08 	sll  %l1, 8, %l1                               
 201c4d4:	a2 14 40 03 	or  %l1, %g3, %l1                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201c4d8:	c6 0f 20 01 	ldub  [ %i4 + 1 ], %g3                         
 201c4dc:	97 2a e0 18 	sll  %o3, 0x18, %o3                            
 201c4e0:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 201c4e4:	96 12 c0 03 	or  %o3, %g3, %o3                              
 201c4e8:	c6 0f 20 03 	ldub  [ %i4 + 3 ], %g3                         
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201c4ec:	80 a4 40 14 	cmp  %l1, %l4                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201c4f0:	96 12 c0 03 	or  %o3, %g3, %o3                              
 201c4f4:	c6 0f 20 02 	ldub  [ %i4 + 2 ], %g3                         
 201c4f8:	87 28 e0 08 	sll  %g3, 8, %g3                               
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201c4fc:	02 80 00 81 	be  201c700 <rtems_rfs_dir_del_entry+0x380>    <== NEVER TAKEN
 201c500:	96 12 c0 03 	or  %o3, %g3, %o3                              
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
 201c504:	80 a4 60 0a 	cmp  %l1, 0xa                                  
 201c508:	24 80 00 0d 	ble,a   201c53c <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
 201c50c:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        <== NOT EXECUTED
 201c510:	c6 07 60 1c 	ld  [ %i5 + 0x1c ], %g3                        
 201c514:	80 a4 40 03 	cmp  %l1, %g3                                  
 201c518:	1a 80 00 08 	bcc  201c538 <rtems_rfs_dir_del_entry+0x1b8>   <== NEVER TAKEN
 201c51c:	80 a2 e0 00 	cmp  %o3, 0                                    
 201c520:	22 80 00 07 	be,a   201c53c <rtems_rfs_dir_del_entry+0x1bc> <== NEVER TAKEN
 201c524:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        <== NOT EXECUTED
 201c528:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
 201c52c:	80 a2 c0 03 	cmp  %o3, %g3                                  
 201c530:	08 80 00 11 	bleu  201c574 <rtems_rfs_dir_del_entry+0x1f4>  <== ALWAYS TAKEN
 201c534:	80 a6 80 0b 	cmp  %i2, %o3                                  
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
 201c538:	d6 27 bf 9c 	st  %o3, [ %fp + -100 ]                        <== NOT EXECUTED
 201c53c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c540:	7f ff dc 72 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c544:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
 201c548:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c54c:	02 80 00 87 	be  201c768 <rtems_rfs_dir_del_entry+0x3e8>    <== NOT EXECUTED
 201c550:	d6 07 bf 9c 	ld  [ %fp + -100 ], %o3                        <== NOT EXECUTED
          printf ("rtems-rfs: dir-del-entry: "                        
 201c554:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201c558:	d8 07 bf a0 	ld  [ %fp + -96 ], %o4                         <== NOT EXECUTED
 201c55c:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
 201c560:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
 201c564:	40 00 16 88 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c568:	9a 10 00 10 	mov  %l0, %o5                                  <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &buffer);                    
 201c56c:	10 80 00 71 	b  201c730 <rtems_rfs_dir_del_entry+0x3b0>     <== NOT EXECUTED
 201c570:	a4 10 20 05 	mov  5, %l2                                    <== NOT EXECUTED
                  rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      if (ino == rtems_rfs_dir_entry_ino (entry))                     
 201c574:	12 80 00 5d 	bne  201c6e8 <rtems_rfs_dir_del_entry+0x368>   <== NEVER TAKEN
 201c578:	80 a4 e0 00 	cmp  %l3, 0                                    
      {                                                               
        uint32_t remaining;                                           
        remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
        memmove (entry, entry + elength, remaining);                  
 201c57c:	92 07 00 11 	add  %i4, %l1, %o1                             
 201c580:	90 10 00 1c 	mov  %i4, %o0                                  
      }                                                               
                                                                      
      if (ino == rtems_rfs_dir_entry_ino (entry))                     
      {                                                               
        uint32_t remaining;                                           
        remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
 201c584:	b6 04 00 11 	add  %l0, %l1, %i3                             
 201c588:	b6 20 40 1b 	sub  %g1, %i3, %i3                             
        memmove (entry, entry + elength, remaining);                  
 201c58c:	40 00 15 ae 	call  2021c44 <memmove>                        
 201c590:	94 10 00 1b 	mov  %i3, %o2                                  
        memset (entry + remaining, 0xff, elength);                    
 201c594:	90 07 00 1b 	add  %i4, %i3, %o0                             
 201c598:	92 10 20 ff 	mov  0xff, %o1                                 
 201c59c:	40 00 15 fc 	call  2021d8c <memset>                         
 201c5a0:	94 10 00 11 	mov  %l1, %o2                                  
         * 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);                 
 201c5a4:	c4 0f 20 08 	ldub  [ %i4 + 8 ], %g2                         
 201c5a8:	c2 0f 20 09 	ldub  [ %i4 + 9 ], %g1                         
 201c5ac:	85 28 a0 08 	sll  %g2, 8, %g2                               
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
 201c5b0:	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);                 
 201c5b4:	b8 10 80 01 	or  %g2, %g1, %i4                              
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
 201c5b8:	7f ff dc 54 	call  2013708 <rtems_rfs_trace>                
 201c5bc:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    
 201c5c0:	80 8a 20 ff 	btst  0xff, %o0                                
 201c5c4:	02 80 00 1a 	be  201c62c <rtems_rfs_dir_del_entry+0x2ac>    <== ALWAYS TAKEN
 201c5c8:	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");    
 201c5cc:	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: "                        
 201c5d0:	d6 07 bf a0 	ld  [ %fp + -96 ], %o3                         <== NOT EXECUTED
 201c5d4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 201c5d8:	12 80 00 08 	bne  201c5f8 <rtems_rfs_dir_del_entry+0x278>   <== NOT EXECUTED
 201c5dc:	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");    
 201c5e0:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
 201c5e4:	12 80 00 06 	bne  201c5fc <rtems_rfs_dir_del_entry+0x27c>   <== NOT EXECUTED
 201c5e8:	84 00 bf ff 	add  %g2, -1, %g2                              <== 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: "                        
 201c5ec:	1b 00 80 ca 	sethi  %hi(0x2032800), %o5                     <== NOT EXECUTED
 201c5f0:	10 80 00 08 	b  201c610 <rtems_rfs_dir_del_entry+0x290>     <== NOT EXECUTED
 201c5f4:	9a 13 63 28 	or  %o5, 0x328, %o5	! 2032b28 <_CPU_Trap_slot_template+0xaf0><== 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");    
 201c5f8:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
 201c5fc:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 201c600:	02 bf ff fc 	be  201c5f0 <rtems_rfs_dir_del_entry+0x270>    <== NOT EXECUTED
 201c604:	1b 00 80 ca 	sethi  %hi(0x2032800), %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: "                        
 201c608:	1b 00 80 c3 	sethi  %hi(0x2030c00), %o5                     <== NOT EXECUTED
 201c60c:	9a 13 60 10 	or  %o5, 0x10, %o5	! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
 201c610:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201c614:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201c618:	90 12 20 28 	or  %o0, 0x28, %o0                             <== NOT EXECUTED
 201c61c:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201c620:	40 00 16 59 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c624:	98 10 00 10 	mov  %l0, %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) &&                 
 201c628:	03 3f ff c0 	sethi  %hi(0xffff0000), %g1                    <== NOT EXECUTED
 201c62c:	b8 38 40 1c 	xnor  %g1, %i4, %i4                            
 201c630:	80 a7 20 00 	cmp  %i4, 0                                    
 201c634:	12 80 00 23 	bne  201c6c0 <rtems_rfs_dir_del_entry+0x340>   
 201c638:	80 a4 20 00 	cmp  %l0, 0                                    
 201c63c:	12 80 00 21 	bne  201c6c0 <rtems_rfs_dir_del_entry+0x340>   <== ALWAYS TAKEN
 201c640:	c2 07 bf c0 	ld  [ %fp + -64 ], %g1                         
            (eoffset == 0) && rtems_rfs_block_map_last (&map))        
 201c644:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 201c648:	12 80 00 05 	bne  201c65c <rtems_rfs_dir_del_entry+0x2dc>   <== NOT EXECUTED
 201c64c:	c4 07 bf b8 	ld  [ %fp + -72 ], %g2                         <== NOT EXECUTED
 201c650:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
 201c654:	02 80 00 07 	be  201c670 <rtems_rfs_dir_del_entry+0x2f0>    <== NOT EXECUTED
 201c658:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c65c:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
 201c660:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 201c664:	12 80 00 18 	bne  201c6c4 <rtems_rfs_dir_del_entry+0x344>   <== NOT EXECUTED
 201c668:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_shrink (fs, &map, 1);              
 201c66c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c670:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
 201c674:	7f ff f9 bf 	call  201ad70 <rtems_rfs_block_map_shrink>     <== NOT EXECUTED
 201c678:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          if (rc > 0)                                                 
 201c67c:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
 201c680:	04 80 00 10 	ble  201c6c0 <rtems_rfs_dir_del_entry+0x340>   <== NOT EXECUTED
 201c684:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
          {                                                           
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))      
 201c688:	7f ff dc 20 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c68c:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
 201c690:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c694:	02 80 00 0c 	be  201c6c4 <rtems_rfs_dir_del_entry+0x344>    <== NOT EXECUTED
 201c698:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
              printf ("rtems-rfs: dir-del-entry: "                    
 201c69c:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
 201c6a0:	40 00 1a a5 	call  2023134 <strerror>                       <== NOT EXECUTED
 201c6a4:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201c6a8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201c6ac:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201c6b0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201c6b4:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201c6b8:	40 00 16 33 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c6bc:	90 12 20 88 	or  %o0, 0x88, %o0	! 2034088 <CSWTCH.2+0xba8>  <== 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);                        
 201c6c0:	82 10 20 01 	mov  1, %g1                                    
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
 201c6c4:	90 10 00 1d 	mov  %i5, %o0                                  
                      "block map shrink failed for ino %" PRIu32 ": %d: %s\n",
                      rtems_rfs_inode_ino (dir), rc, strerror (rc));  
          }                                                           
        }                                                             
                                                                      
        rtems_rfs_buffer_mark_dirty (&buffer);                        
 201c6c8:	c2 2f bf a4 	stb  %g1, [ %fp + -92 ]                        
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
 201c6cc:	7f ff fd 00 	call  201bacc <rtems_rfs_buffer_handle_close>  
 201c6d0:	92 07 bf a4 	add  %fp, -92, %o1                             
        rtems_rfs_block_map_close (fs, &map);                         
 201c6d4:	90 10 00 1d 	mov  %i5, %o0                                  
 201c6d8:	7f ff f7 bc 	call  201a5c8 <rtems_rfs_block_map_close>      
 201c6dc:	92 07 bf b0 	add  %fp, -80, %o1                             
 201c6e0:	81 c7 e0 08 	ret                                            
 201c6e4:	81 e8 00 00 	restore                                        
        return 0;                                                     
      }                                                               
                                                                      
      if (!search)                                                    
 201c6e8:	02 80 00 20 	be  201c768 <rtems_rfs_dir_del_entry+0x3e8>    <== NOT EXECUTED
 201c6ec:	b8 07 00 11 	add  %i4, %l1, %i4                             <== NOT EXECUTED
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
 201c6f0:	a0 04 00 11 	add  %l0, %l1, %l0                             <== 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))
 201c6f4:	80 a4 00 02 	cmp  %l0, %g2                                  
 201c6f8:	2a bf ff 74 	bcs,a   201c4c8 <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
 201c6fc:	c6 0f 20 09 	ldub  [ %i4 + 9 ], %g3                         
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
    }                                                                 
                                                                      
    if (rc == 0)                                                      
 201c700:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
 201c704:	32 80 00 0c 	bne,a   201c734 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
 201c708:	b0 10 00 12 	mov  %l2, %i0                                  <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
 201c70c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c710:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
 201c714:	7f ff f8 9a 	call  201a97c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
 201c718:	94 10 00 16 	mov  %l6, %o2                                  <== NOT EXECUTED
      if (rc == ENXIO)                                                
 201c71c:	80 a2 20 06 	cmp  %o0, 6                                    <== NOT EXECUTED
 201c720:	12 80 00 05 	bne  201c734 <rtems_rfs_dir_del_entry+0x3b4>   <== NOT EXECUTED
 201c724:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
        rc = ENOENT;                                                  
 201c728:	10 80 00 06 	b  201c740 <rtems_rfs_dir_del_entry+0x3c0>     <== NOT EXECUTED
 201c72c:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &buffer);                    
 201c730:	b0 10 00 12 	mov  %l2, %i0                                  <== NOT EXECUTED
  /*                                                                  
   * Only search if the offset is 0 else we are at that position.     
   */                                                                 
  search = offset ? false : true;                                     
                                                                      
  while (rc == 0)                                                     
 201c734:	80 a6 20 00 	cmp  %i0, 0                                    
 201c738:	02 bf ff 40 	be  201c438 <rtems_rfs_dir_del_entry+0xb8>     <== ALWAYS TAKEN
 201c73c:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
 201c740:	a4 10 00 18 	mov  %i0, %l2                                  <== NOT EXECUTED
      if (rc == ENXIO)                                                
        rc = ENOENT;                                                  
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201c744:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
 201c748:	7f ff fc e1 	call  201bacc <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201c74c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  rtems_rfs_block_map_close (fs, &map);                               
 201c750:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201c754:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
 201c758:	7f ff f7 9c 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201c75c:	b0 10 00 12 	mov  %l2, %i0                                  <== NOT EXECUTED
 201c760:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201c764:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &buffer);                    
 201c768:	10 bf ff f2 	b  201c730 <rtems_rfs_dir_del_entry+0x3b0>     <== NOT EXECUTED
 201c76c:	a4 10 20 05 	mov  5, %l2                                    <== NOT EXECUTED
                                                                      

0201cb08 <rtems_rfs_dir_empty>: int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) {
 201cb08:	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))                     
 201cb0c:	90 10 20 00 	clr  %o0                                       
 201cb10:	7f ff da fe 	call  2013708 <rtems_rfs_trace>                
 201cb14:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
 201cb18:	80 8a 20 ff 	btst  0xff, %o0                                
 201cb1c:	02 80 00 07 	be  201cb38 <rtems_rfs_dir_empty+0x30>         <== ALWAYS TAKEN
 201cb20:	b8 07 bf b0 	add  %fp, -80, %i4                             
    printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
 201cb24:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201cb28:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201cb2c:	40 00 15 16 	call  2021f84 <printf>                         <== NOT EXECUTED
 201cb30:	90 12 21 b8 	or  %o0, 0x1b8, %o0	! 20341b8 <CSWTCH.2+0xcd8> <== NOT EXECUTED
                                                                      
  empty = true;                                                       
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
 201cb34:	b8 07 bf b0 	add  %fp, -80, %i4                             <== NOT EXECUTED
 201cb38:	90 10 00 18 	mov  %i0, %o0                                  
 201cb3c:	92 10 00 19 	mov  %i1, %o1                                  
 201cb40:	7f ff f6 41 	call  201a444 <rtems_rfs_block_map_open>       
 201cb44:	94 10 00 1c 	mov  %i4, %o2                                  
  if (rc > 0)                                                         
 201cb48:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201cb4c:	34 80 00 82 	bg,a   201cd54 <rtems_rfs_dir_empty+0x24c>     <== NEVER TAKEN
 201cb50:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);                
 201cb54:	b6 07 bf a0 	add  %fp, -96, %i3                             
 201cb58:	90 10 00 18 	mov  %i0, %o0                                  
 201cb5c:	92 10 00 1c 	mov  %i4, %o1                                  
 201cb60:	94 10 20 00 	clr  %o2                                       
 201cb64:	96 10 20 00 	clr  %o3                                       
 201cb68:	7f ff f7 68 	call  201a908 <rtems_rfs_block_map_seek>       
 201cb6c:	98 10 00 1b 	mov  %i3, %o4                                  
  if (rc > 0)                                                         
 201cb70:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201cb74:	04 80 00 05 	ble  201cb88 <rtems_rfs_dir_empty+0x80>        <== ALWAYS TAKEN
 201cb78:	25 00 00 3f 	sethi  %hi(0xfc00), %l2                        
  {                                                                   
    rtems_rfs_block_map_close (fs, &map);                             
 201cb7c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201cb80:	10 80 00 69 	b  201cd24 <rtems_rfs_dir_empty+0x21c>         <== NOT EXECUTED
 201cb84:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))              
          printf ("rtems-rfs: dir-empty: "                            
 201cb88:	27 00 80 d0 	sethi  %hi(0x2034000), %l3                     
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201cb8c:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
 201cb90:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
 201cb94:	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)                       
 201cb98:	a4 14 a3 ff 	or  %l2, 0x3ff, %l2                            
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))              
          printf ("rtems-rfs: dir-empty: "                            
 201cb9c:	a6 14 e1 d8 	or  %l3, 0x1d8, %l3                            
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
 201cba0:	a2 10 00 1c 	mov  %i4, %l1                                  
 201cba4:	a0 10 00 1b 	mov  %i3, %l0                                  
  while (empty)                                                       
  {                                                                   
    uint8_t* entry;                                                   
    int      offset;                                                  
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
 201cba8:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
 201cbac:	90 10 00 18 	mov  %i0, %o0                                  
 201cbb0:	92 07 bf a4 	add  %fp, -92, %o1                             
 201cbb4:	7f ff fa 11 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201cbb8:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
 201cbbc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201cbc0:	14 80 00 4c 	bg  201ccf0 <rtems_rfs_dir_empty+0x1e8>        <== NEVER TAKEN
 201cbc4:	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))
 201cbc8:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
    if (rc > 0)                                                       
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
 201cbcc:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201cbd0:	84 00 bf f6 	add  %g2, -10, %g2                             
 201cbd4:	10 80 00 3b 	b  201ccc0 <rtems_rfs_dir_empty+0x1b8>         
 201cbd8:	b6 10 20 00 	clr  %i3                                       
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
 201cbdc:	f8 08 60 08 	ldub  [ %g1 + 8 ], %i4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201cbe0:	f4 08 40 00 	ldub  [ %g1 ], %i2                             
    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);                   
 201cbe4:	b9 2f 20 08 	sll  %i4, 8, %i4                               
 201cbe8:	b8 17 00 03 	or  %i4, %g3, %i4                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201cbec:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
 201cbf0:	b5 2e a0 18 	sll  %i2, 0x18, %i2                            
 201cbf4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 201cbf8:	b4 16 80 03 	or  %i2, %g3, %i2                              
 201cbfc:	c6 08 60 03 	ldub  [ %g1 + 3 ], %g3                         
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201cc00:	80 a7 00 12 	cmp  %i4, %l2                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
      eino    = rtems_rfs_dir_entry_ino (entry);                      
 201cc04:	b4 16 80 03 	or  %i2, %g3, %i2                              
 201cc08:	c6 08 60 02 	ldub  [ %g1 + 2 ], %g3                         
 201cc0c:	87 28 e0 08 	sll  %g3, 8, %g3                               
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
 201cc10:	02 80 00 48 	be  201cd30 <rtems_rfs_dir_empty+0x228>        
 201cc14:	b4 16 80 03 	or  %i2, %g3, %i2                              
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
 201cc18:	80 a7 20 0a 	cmp  %i4, 0xa                                  
 201cc1c:	04 80 00 0d 	ble  201cc50 <rtems_rfs_dir_empty+0x148>       <== NEVER TAKEN
 201cc20:	90 10 20 01 	mov  1, %o0                                    
 201cc24:	c6 06 20 1c 	ld  [ %i0 + 0x1c ], %g3                        
 201cc28:	80 a7 00 03 	cmp  %i4, %g3                                  
 201cc2c:	1a 80 00 09 	bcc  201cc50 <rtems_rfs_dir_empty+0x148>       <== NEVER TAKEN
 201cc30:	80 a6 a0 00 	cmp  %i2, 0                                    
 201cc34:	02 80 00 07 	be  201cc50 <rtems_rfs_dir_empty+0x148>        <== NEVER TAKEN
 201cc38:	01 00 00 00 	nop                                            
 201cc3c:	c6 06 20 14 	ld  [ %i0 + 0x14 ], %g3                        
 201cc40:	80 a6 80 03 	cmp  %i2, %g3                                  
 201cc44:	08 80 00 10 	bleu  201cc84 <rtems_rfs_dir_empty+0x17c>      <== ALWAYS TAKEN
 201cc48:	80 a7 20 0b 	cmp  %i4, 0xb                                  
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))              
 201cc4c:	90 10 20 01 	mov  1, %o0                                    <== NOT EXECUTED
 201cc50:	7f ff da ae 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201cc54:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201cc58:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201cc5c:	22 80 00 36 	be,a   201cd34 <rtems_rfs_dir_empty+0x22c>     <== NOT EXECUTED
 201cc60:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
          printf ("rtems-rfs: dir-empty: "                            
 201cc64:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201cc68:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
 201cc6c:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201cc70:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
 201cc74:	40 00 14 c4 	call  2021f84 <printf>                         <== NOT EXECUTED
 201cc78:	98 10 00 1b 	mov  %i3, %o4                                  <== NOT EXECUTED
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
 201cc7c:	10 80 00 2e 	b  201cd34 <rtems_rfs_dir_empty+0x22c>         <== NOT EXECUTED
 201cc80:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
      /*                                                              
       * Ignore the current (.) and parent (..) entries. Anything else means
       * the directory is not empty.                                  
       */                                                             
      if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||             
 201cc84:	12 80 00 04 	bne  201cc94 <rtems_rfs_dir_empty+0x18c>       
 201cc88:	80 a7 20 0c 	cmp  %i4, 0xc                                  
 201cc8c:	10 80 00 09 	b  201ccb0 <rtems_rfs_dir_empty+0x1a8>         
 201cc90:	c6 08 60 0a 	ldub  [ %g1 + 0xa ], %g3                       
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&               
 201cc94:	32 80 00 18 	bne,a   201ccf4 <rtems_rfs_dir_empty+0x1ec>    
 201cc98:	82 10 20 00 	clr  %g1                                       
          ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||             
 201cc9c:	c6 08 60 0a 	ldub  [ %g1 + 0xa ], %g3                       
 201cca0:	80 a0 e0 2e 	cmp  %g3, 0x2e                                 
 201cca4:	32 80 00 14 	bne,a   201ccf4 <rtems_rfs_dir_empty+0x1ec>    <== NEVER TAKEN
 201cca8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||                
 201ccac:	c6 08 60 0b 	ldub  [ %g1 + 0xb ], %g3                       
 201ccb0:	80 a0 e0 2e 	cmp  %g3, 0x2e                                 
 201ccb4:	12 80 00 0c 	bne  201cce4 <rtems_rfs_dir_empty+0x1dc>       <== NEVER TAKEN
 201ccb8:	b6 06 c0 1c 	add  %i3, %i4, %i3                             
      {                                                               
        empty = false;                                                
        break;                                                        
      }                                                               
                                                                      
      entry  += elength;                                              
 201ccbc:	82 00 40 1c 	add  %g1, %i4, %g1                             
      break;                                                          
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201ccc0:	80 a6 c0 02 	cmp  %i3, %g2                                  
 201ccc4:	2a bf ff c6 	bcs,a   201cbdc <rtems_rfs_dir_empty+0xd4>     <== ALWAYS TAKEN
 201ccc8:	c6 08 60 09 	ldub  [ %g1 + 9 ], %g3                         
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
 201cccc:	10 80 00 1a 	b  201cd34 <rtems_rfs_dir_empty+0x22c>         <== NOT EXECUTED
 201ccd0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      if (rc > 0)                                                     
      {                                                               
        if (rc == ENXIO)                                              
 201ccd4:	02 80 00 06 	be  201ccec <rtems_rfs_dir_empty+0x1e4>        <== ALWAYS TAKEN
 201ccd8:	82 10 20 01 	mov  1, %g1                                    
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ((rc == 0) && !empty)                                            
 201ccdc:	10 80 00 07 	b  201ccf8 <rtems_rfs_dir_empty+0x1f0>         <== NOT EXECUTED
 201cce0:	82 18 60 01 	xor  %g1, 1, %g1                               <== NOT EXECUTED
       * the directory is not empty.                                  
       */                                                             
      if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||             
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&               
          ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||             
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||                
 201cce4:	10 80 00 04 	b  201ccf4 <rtems_rfs_dir_empty+0x1ec>         <== NOT EXECUTED
 201cce8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
      if (rc > 0)                                                     
      {                                                               
        if (rc == ENXIO)                                              
          rc = 0;                                                     
 201ccec:	ba 10 20 00 	clr  %i5                                       
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
      if (rc > 0)                                                     
      {                                                               
        if (rc == ENXIO)                                              
 201ccf0:	82 10 20 01 	mov  1, %g1                                    
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ((rc == 0) && !empty)                                            
 201ccf4:	82 18 60 01 	xor  %g1, 1, %g1                               
 201ccf8:	80 88 60 ff 	btst  0xff, %g1                                
 201ccfc:	02 80 00 06 	be  201cd14 <rtems_rfs_dir_empty+0x20c>        
 201cd00:	92 07 bf a4 	add  %fp, -92, %o1                             
 201cd04:	80 a7 60 00 	cmp  %i5, 0                                    
 201cd08:	22 80 00 03 	be,a   201cd14 <rtems_rfs_dir_empty+0x20c>     <== ALWAYS TAKEN
 201cd0c:	ba 10 20 5a 	mov  0x5a, %i5                                 
    rc = ENOTEMPTY;                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201cd10:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
 201cd14:	7f ff fb 6e 	call  201bacc <rtems_rfs_buffer_handle_close>  
 201cd18:	90 10 00 18 	mov  %i0, %o0                                  
  rtems_rfs_block_map_close (fs, &map);                               
 201cd1c:	90 10 00 18 	mov  %i0, %o0                                  
 201cd20:	92 07 bf b0 	add  %fp, -80, %o1                             
 201cd24:	7f ff f6 29 	call  201a5c8 <rtems_rfs_block_map_close>      
 201cd28:	b0 10 00 1d 	mov  %i5, %i0                                  
 201cd2c:	30 80 00 0a 	b,a   201cd54 <rtems_rfs_dir_empty+0x24c>      
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
 201cd30:	90 10 00 18 	mov  %i0, %o0                                  
 201cd34:	92 10 00 11 	mov  %l1, %o1                                  
 201cd38:	7f ff f7 11 	call  201a97c <rtems_rfs_block_map_next_block> 
 201cd3c:	94 10 00 10 	mov  %l0, %o2                                  
      if (rc > 0)                                                     
 201cd40:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201cd44:	24 bf ff 9a 	ble,a   201cbac <rtems_rfs_dir_empty+0xa4>     <== NEVER TAKEN
 201cd48:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         <== NOT EXECUTED
      {                                                               
        if (rc == ENXIO)                                              
 201cd4c:	10 bf ff e2 	b  201ccd4 <rtems_rfs_dir_empty+0x1cc>         
 201cd50:	80 a7 60 06 	cmp  %i5, 6                                    
    rc = ENOTEMPTY;                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
 201cd54:	81 c7 e0 08 	ret                                            
 201cd58:	81 e8 00 00 	restore                                        
                                                                      

02020670 <rtems_rfs_dir_hash>: { uint32_t a,b,c; /* internal state */ union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */ /* Set up the internal state */ a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
 2020670:	05 37 f7 c5 	sethi  %hi(0xdfdf1400), %g2                    
 2020674:	84 10 a2 9f 	or  %g2, 0x29f, %g2	! dfdf169f <RAM_END+0xdd9f169f>
 2020678:	84 02 40 02 	add  %o1, %g2, %g2                             
 202067c:	86 10 00 02 	mov  %g2, %g3                                  
                                                                      
  } 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)                                               
 2020680:	10 80 00 48 	b  20207a0 <rtems_rfs_dir_hash+0x130>          
 2020684:	88 10 00 02 	mov  %g2, %g4                                  
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
 2020688:	d8 0a 20 02 	ldub  [ %o0 + 2 ], %o4                         
    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];                                                      
 202068c:	88 03 40 04 	add  %o5, %g4, %g4                             
      a += ((uint32_t)k[1])<<8;                                       
 2020690:	da 0a 20 01 	ldub  [ %o0 + 1 ], %o5                         
      a += ((uint32_t)k[2])<<16;                                      
 2020694:	99 2b 20 10 	sll  %o4, 0x10, %o4                            
                                                                      
    /*--------------- 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;                                       
 2020698:	9b 2b 60 08 	sll  %o5, 8, %o5                               
 202069c:	9a 01 00 0d 	add  %g4, %o5, %o5                             
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
 20206a0:	c8 0a 20 04 	ldub  [ %o0 + 4 ], %g4                         
    /*--------------- 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;                                      
 20206a4:	9a 03 40 0c 	add  %o5, %o4, %o5                             
      a += ((uint32_t)k[3])<<24;                                      
      b += k[4];                                                      
 20206a8:	86 01 00 03 	add  %g4, %g3, %g3                             
      b += ((uint32_t)k[5])<<8;                                       
 20206ac:	c8 0a 20 05 	ldub  [ %o0 + 5 ], %g4                         
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
 20206b0:	d8 0a 20 03 	ldub  [ %o0 + 3 ], %o4                         
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
 20206b4:	89 29 20 08 	sll  %g4, 8, %g4                               
 20206b8:	86 00 c0 04 	add  %g3, %g4, %g3                             
      b += ((uint32_t)k[6])<<16;                                      
 20206bc:	c8 0a 20 06 	ldub  [ %o0 + 6 ], %g4                         
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
 20206c0:	99 2b 20 18 	sll  %o4, 0x18, %o4                            
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
 20206c4:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 20206c8:	86 00 c0 04 	add  %g3, %g4, %g3                             
      b += ((uint32_t)k[7])<<24;                                      
 20206cc:	c8 0a 20 07 	ldub  [ %o0 + 7 ], %g4                         
    while (length > 12)                                               
    {                                                                 
      a += k[0];                                                      
      a += ((uint32_t)k[1])<<8;                                       
      a += ((uint32_t)k[2])<<16;                                      
      a += ((uint32_t)k[3])<<24;                                      
 20206d0:	9a 03 40 0c 	add  %o5, %o4, %o5                             
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
      b += ((uint32_t)k[6])<<16;                                      
      b += ((uint32_t)k[7])<<24;                                      
 20206d4:	89 29 20 18 	sll  %g4, 0x18, %g4                            
 20206d8:	86 00 c0 04 	add  %g3, %g4, %g3                             
      c += k[8];                                                      
 20206dc:	c8 0a 20 08 	ldub  [ %o0 + 8 ], %g4                         
      c += ((uint32_t)k[9])<<8;                                       
      c += ((uint32_t)k[10])<<16;                                     
      c += ((uint32_t)k[11])<<24;                                     
      mix(a,b,c);                                                     
      length -= 12;                                                   
 20206e0:	92 02 7f f4 	add  %o1, -12, %o1                             
      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];                                                      
 20206e4:	84 01 00 02 	add  %g4, %g2, %g2                             
      c += ((uint32_t)k[9])<<8;                                       
 20206e8:	c8 0a 20 09 	ldub  [ %o0 + 9 ], %g4                         
 20206ec:	89 29 20 08 	sll  %g4, 8, %g4                               
 20206f0:	84 00 80 04 	add  %g2, %g4, %g2                             
      c += ((uint32_t)k[10])<<16;                                     
 20206f4:	c8 0a 20 0a 	ldub  [ %o0 + 0xa ], %g4                       
 20206f8:	89 29 20 10 	sll  %g4, 0x10, %g4                            
 20206fc:	84 00 80 04 	add  %g2, %g4, %g2                             
      c += ((uint32_t)k[11])<<24;                                     
 2020700:	c8 0a 20 0b 	ldub  [ %o0 + 0xb ], %g4                       
      mix(a,b,c);                                                     
      length -= 12;                                                   
      k += 12;                                                        
 2020704:	90 02 20 0c 	add  %o0, 0xc, %o0                             
      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;                                     
 2020708:	89 29 20 18 	sll  %g4, 0x18, %g4                            
 202070c:	84 00 80 04 	add  %g2, %g4, %g2                             
      mix(a,b,c);                                                     
 2020710:	9a 23 40 02 	sub  %o5, %g2, %o5                             
 2020714:	99 28 a0 04 	sll  %g2, 4, %o4                               
 2020718:	89 30 a0 1c 	srl  %g2, 0x1c, %g4                            
 202071c:	88 13 00 04 	or  %o4, %g4, %g4                              
 2020720:	88 1b 40 04 	xor  %o5, %g4, %g4                             
 2020724:	99 29 20 06 	sll  %g4, 6, %o4                               
 2020728:	9b 31 20 1a 	srl  %g4, 0x1a, %o5                            
 202072c:	9a 13 00 0d 	or  %o4, %o5, %o5                              
 2020730:	84 00 80 03 	add  %g2, %g3, %g2                             
 2020734:	86 20 c0 04 	sub  %g3, %g4, %g3                             
 2020738:	86 1b 40 03 	xor  %o5, %g3, %g3                             
 202073c:	99 28 e0 08 	sll  %g3, 8, %o4                               
 2020740:	9b 30 e0 18 	srl  %g3, 0x18, %o5                            
 2020744:	9a 13 00 0d 	or  %o4, %o5, %o5                              
 2020748:	88 01 00 02 	add  %g4, %g2, %g4                             
 202074c:	84 20 80 03 	sub  %g2, %g3, %g2                             
 2020750:	84 1b 40 02 	xor  %o5, %g2, %g2                             
 2020754:	99 28 a0 10 	sll  %g2, 0x10, %o4                            
 2020758:	9b 30 a0 10 	srl  %g2, 0x10, %o5                            
 202075c:	9a 13 00 0d 	or  %o4, %o5, %o5                              
 2020760:	86 00 c0 04 	add  %g3, %g4, %g3                             
 2020764:	88 21 00 02 	sub  %g4, %g2, %g4                             
 2020768:	88 1b 40 04 	xor  %o5, %g4, %g4                             
 202076c:	99 29 20 13 	sll  %g4, 0x13, %o4                            
 2020770:	9b 31 20 0d 	srl  %g4, 0xd, %o5                             
 2020774:	9a 13 00 0d 	or  %o4, %o5, %o5                              
 2020778:	84 00 80 03 	add  %g2, %g3, %g2                             
 202077c:	86 20 c0 04 	sub  %g3, %g4, %g3                             
 2020780:	88 01 00 02 	add  %g4, %g2, %g4                             
 2020784:	86 1b 40 03 	xor  %o5, %g3, %g3                             
 2020788:	84 20 80 03 	sub  %g2, %g3, %g2                             
 202078c:	99 28 e0 04 	sll  %g3, 4, %o4                               
 2020790:	9b 30 e0 1c 	srl  %g3, 0x1c, %o5                            
 2020794:	86 00 c0 04 	add  %g3, %g4, %g3                             
 2020798:	9a 13 00 0d 	or  %o4, %o5, %o5                              
 202079c:	84 1b 40 02 	xor  %o5, %g2, %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)                                               
 20207a0:	80 a2 60 0c 	cmp  %o1, 0xc                                  
 20207a4:	38 bf ff b9 	bgu,a   2020688 <rtems_rfs_dir_hash+0x18>      
 20207a8:	da 0a 00 00 	ldub  [ %o0 ], %o5                             
      length -= 12;                                                   
      k += 12;                                                        
    }                                                                 
                                                                      
    /*-------------------------------- last block: affect all 32 bits of (c) */
    switch(length)                   /* all the case statements fall through */
 20207ac:	92 02 7f ff 	add  %o1, -1, %o1                              
 20207b0:	80 a2 60 0b 	cmp  %o1, 0xb                                  
 20207b4:	18 80 00 4b 	bgu  20208e0 <rtems_rfs_dir_hash+0x270>        <== NEVER TAKEN
 20207b8:	93 2a 60 02 	sll  %o1, 2, %o1                               
 20207bc:	1b 00 80 81 	sethi  %hi(0x2020400), %o5                     
 20207c0:	9a 13 62 40 	or  %o5, 0x240, %o5	! 2020640 <rtems_rfs_buffer_bdbuf_release+0x80>
 20207c4:	da 03 40 09 	ld  [ %o5 + %o1 ], %o5                         
 20207c8:	81 c3 40 00 	jmp  %o5                                       
 20207cc:	01 00 00 00 	nop                                            
    {                                                                 
      case 12: c+=((uint32_t)k[11])<<24;                              
 20207d0:	da 0a 20 0b 	ldub  [ %o0 + 0xb ], %o5                       
 20207d4:	9b 2b 60 18 	sll  %o5, 0x18, %o5                            
 20207d8:	84 03 40 02 	add  %o5, %g2, %g2                             
      case 11: c+=((uint32_t)k[10])<<16;                              
 20207dc:	da 0a 20 0a 	ldub  [ %o0 + 0xa ], %o5                       
 20207e0:	9b 2b 60 10 	sll  %o5, 0x10, %o5                            
 20207e4:	84 00 80 0d 	add  %g2, %o5, %g2                             
      case 10: c+=((uint32_t)k[9])<<8;                                
 20207e8:	da 0a 20 09 	ldub  [ %o0 + 9 ], %o5                         
 20207ec:	9b 2b 60 08 	sll  %o5, 8, %o5                               
 20207f0:	84 00 80 0d 	add  %g2, %o5, %g2                             
      case 9 : c+=k[8];                                               
 20207f4:	da 0a 20 08 	ldub  [ %o0 + 8 ], %o5                         
 20207f8:	84 00 80 0d 	add  %g2, %o5, %g2                             
      case 8 : b+=((uint32_t)k[7])<<24;                               
 20207fc:	da 0a 20 07 	ldub  [ %o0 + 7 ], %o5                         
 2020800:	9b 2b 60 18 	sll  %o5, 0x18, %o5                            
 2020804:	86 03 40 03 	add  %o5, %g3, %g3                             
      case 7 : b+=((uint32_t)k[6])<<16;                               
 2020808:	da 0a 20 06 	ldub  [ %o0 + 6 ], %o5                         
 202080c:	9b 2b 60 10 	sll  %o5, 0x10, %o5                            
 2020810:	86 00 c0 0d 	add  %g3, %o5, %g3                             
      case 6 : b+=((uint32_t)k[5])<<8;                                
 2020814:	da 0a 20 05 	ldub  [ %o0 + 5 ], %o5                         
 2020818:	9b 2b 60 08 	sll  %o5, 8, %o5                               
 202081c:	86 00 c0 0d 	add  %g3, %o5, %g3                             
      case 5 : b+=k[4];                                               
 2020820:	da 0a 20 04 	ldub  [ %o0 + 4 ], %o5                         
 2020824:	86 00 c0 0d 	add  %g3, %o5, %g3                             
      case 4 : a+=((uint32_t)k[3])<<24;                               
 2020828:	da 0a 20 03 	ldub  [ %o0 + 3 ], %o5                         
 202082c:	9b 2b 60 18 	sll  %o5, 0x18, %o5                            
 2020830:	88 03 40 04 	add  %o5, %g4, %g4                             
      case 3 : a+=((uint32_t)k[2])<<16;                               
 2020834:	da 0a 20 02 	ldub  [ %o0 + 2 ], %o5                         
 2020838:	9b 2b 60 10 	sll  %o5, 0x10, %o5                            
 202083c:	88 01 00 0d 	add  %g4, %o5, %g4                             
      case 2 : a+=((uint32_t)k[1])<<8;                                
 2020840:	da 0a 20 01 	ldub  [ %o0 + 1 ], %o5                         
 2020844:	9b 2b 60 08 	sll  %o5, 8, %o5                               
 2020848:	88 01 00 0d 	add  %g4, %o5, %g4                             
      case 1 : a+=k[0];                                               
 202084c:	c2 0a 00 00 	ldub  [ %o0 ], %g1                             
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
 2020850:	9b 30 e0 12 	srl  %g3, 0x12, %o5                            
      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];                                               
 2020854:	88 01 00 01 	add  %g4, %g1, %g4                             
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
 2020858:	83 28 e0 0e 	sll  %g3, 0xe, %g1                             
 202085c:	82 13 40 01 	or  %o5, %g1, %g1                              
 2020860:	84 18 80 03 	xor  %g2, %g3, %g2                             
 2020864:	84 20 80 01 	sub  %g2, %g1, %g2                             
 2020868:	9b 28 a0 0b 	sll  %g2, 0xb, %o5                             
 202086c:	83 30 a0 15 	srl  %g2, 0x15, %g1                            
 2020870:	82 13 40 01 	or  %o5, %g1, %g1                              
 2020874:	88 18 80 04 	xor  %g2, %g4, %g4                             
 2020878:	88 21 00 01 	sub  %g4, %g1, %g4                             
 202087c:	9b 29 20 19 	sll  %g4, 0x19, %o5                            
 2020880:	83 31 20 07 	srl  %g4, 7, %g1                               
 2020884:	82 13 40 01 	or  %o5, %g1, %g1                              
 2020888:	86 19 00 03 	xor  %g4, %g3, %g3                             
 202088c:	86 20 c0 01 	sub  %g3, %g1, %g3                             
 2020890:	9b 28 e0 10 	sll  %g3, 0x10, %o5                            
 2020894:	83 30 e0 10 	srl  %g3, 0x10, %g1                            
 2020898:	82 13 40 01 	or  %o5, %g1, %g1                              
 202089c:	84 18 c0 02 	xor  %g3, %g2, %g2                             
 20208a0:	84 20 80 01 	sub  %g2, %g1, %g2                             
 20208a4:	9b 28 a0 04 	sll  %g2, 4, %o5                               
 20208a8:	83 30 a0 1c 	srl  %g2, 0x1c, %g1                            
 20208ac:	82 13 40 01 	or  %o5, %g1, %g1                              
 20208b0:	88 18 80 04 	xor  %g2, %g4, %g4                             
 20208b4:	88 21 00 01 	sub  %g4, %g1, %g4                             
 20208b8:	83 29 20 0e 	sll  %g4, 0xe, %g1                             
 20208bc:	86 19 00 03 	xor  %g4, %g3, %g3                             
 20208c0:	89 31 20 12 	srl  %g4, 0x12, %g4                            
 20208c4:	88 10 40 04 	or  %g1, %g4, %g4                              
 20208c8:	86 20 c0 04 	sub  %g3, %g4, %g3                             
 20208cc:	84 18 c0 02 	xor  %g3, %g2, %g2                             
 20208d0:	83 28 e0 18 	sll  %g3, 0x18, %g1                            
 20208d4:	87 30 e0 08 	srl  %g3, 8, %g3                               
 20208d8:	86 10 40 03 	or  %g1, %g3, %g3                              
 20208dc:	84 20 80 03 	sub  %g2, %g3, %g2                             
  return c;                                                           
}                                                                     
 20208e0:	81 c3 e0 08 	retl                                           
 20208e4:	90 10 00 02 	mov  %g2, %o0                                  
                                                                      

0201baf4 <rtems_rfs_dir_lookup_ino>: rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) {
 201baf4:	9d e3 bf 38 	save  %sp, -200, %sp                           
  rtems_rfs_block_map     map;                                        
  rtems_rfs_buffer_handle entries;                                    
  int                     rc;                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))               
 201baf8:	90 10 20 00 	clr  %o0                                       
 201bafc:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     
 201bb00:	7f ff df 02 	call  2013708 <rtems_rfs_trace>                
 201bb04:	a0 10 00 18 	mov  %i0, %l0                                  
 201bb08:	80 8a 20 ff 	btst  0xff, %o0                                
 201bb0c:	22 80 00 13 	be,a   201bb58 <rtems_rfs_dir_lookup_ino+0x64> <== ALWAYS TAKEN
 201bb10:	c0 27 00 00 	clr  [ %i4 ]                                   
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
 201bb14:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201bb18:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
            inode->ino);                                              
    for (c = 0; c < length; c++)                                      
 201bb1c:	b0 10 20 00 	clr  %i0                                       <== 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=",
 201bb20:	40 00 19 19 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bb24:	90 12 23 20 	or  %o0, 0x320, %o0                            <== NOT EXECUTED
            inode->ino);                                              
    for (c = 0; c < length; c++)                                      
 201bb28:	10 80 00 05 	b  201bb3c <rtems_rfs_dir_lookup_ino+0x48>     <== NOT EXECUTED
 201bb2c:	80 a6 00 1b 	cmp  %i0, %i3                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
 201bb30:	40 00 19 7f 	call  202212c <putchar>                        <== NOT EXECUTED
 201bb34:	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++)                                      
 201bb38:	80 a6 00 1b 	cmp  %i0, %i3                                  <== NOT EXECUTED
 201bb3c:	26 bf ff fd 	bl,a   201bb30 <rtems_rfs_dir_lookup_ino+0x3c> <== NOT EXECUTED
 201bb40:	d0 4e 80 18 	ldsb  [ %i2 + %i0 ], %o0                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
 201bb44:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201bb48:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201bb4c:	40 00 19 0e 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bb50:	90 12 23 58 	or  %o0, 0x358, %o0                            <== NOT EXECUTED
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
 201bb54:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
  *offset = 0;                                                        
 201bb58:	c0 27 40 00 	clr  [ %i5 ]                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
 201bb5c:	90 10 00 10 	mov  %l0, %o0                                  
 201bb60:	92 10 00 19 	mov  %i1, %o1                                  
 201bb64:	7f ff fa 38 	call  201a444 <rtems_rfs_block_map_open>       
 201bb68:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
 201bb6c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201bb70:	04 80 00 12 	ble  201bbb8 <rtems_rfs_dir_lookup_ino+0xc4>   <== ALWAYS TAKEN
 201bb74:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))             
 201bb78:	7f ff de e4 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201bb7c:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
 201bb80:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201bb84:	02 80 01 18 	be  201bfe4 <rtems_rfs_dir_lookup_ino+0x4f0>   <== NOT EXECUTED
 201bb88:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
 201bb8c:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
 201bb90:	40 00 1d 69 	call  2023134 <strerror>                       <== NOT EXECUTED
 201bb94:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201bb98:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201bb9c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201bba0:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
 201bba4:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201bba8:	40 00 18 f7 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bbac:	90 12 23 68 	or  %o0, 0x368, %o0	! 2033b68 <CSWTCH.2+0x688> <== NOT EXECUTED
 201bbb0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201bbb4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    uint32_t           hash;                                          
                                                                      
    /*                                                                
     * Calculate the hash of the look up string.                      
     */                                                               
    hash = rtems_rfs_dir_hash (name, length);                         
 201bbb8:	92 10 00 1b 	mov  %i3, %o1                                  
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201bbbc:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
 201bbc0:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
 201bbc4:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
 201bbc8:	40 00 12 aa 	call  2020670 <rtems_rfs_dir_hash>             
 201bbcc:	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);              
 201bbd0:	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);                         
 201bbd4:	d0 27 bf 9c 	st  %o0, [ %fp + -100 ]                        
                                                                      
    /*                                                                
     * 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);              
 201bbd8:	94 10 20 00 	clr  %o2                                       
 201bbdc:	90 10 00 10 	mov  %l0, %o0                                  
 201bbe0:	96 10 20 00 	clr  %o3                                       
 201bbe4:	7f ff fb 49 	call  201a908 <rtems_rfs_block_map_seek>       
 201bbe8:	98 07 bf a0 	add  %fp, -96, %o4                             
    if (rc > 0)                                                       
 201bbec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201bbf0:	04 80 00 d3 	ble  201bf3c <rtems_rfs_dir_lookup_ino+0x448>  <== ALWAYS TAKEN
 201bbf4:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
 201bbf8:	7f ff de c4 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201bbfc:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
 201bc00:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201bc04:	02 80 00 0a 	be  201bc2c <rtems_rfs_dir_lookup_ino+0x138>   <== NOT EXECUTED
 201bc08:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
 201bc0c:	40 00 1d 4a 	call  2023134 <strerror>                       <== NOT EXECUTED
 201bc10:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201bc14:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 201bc18:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201bc1c:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201bc20:	40 00 18 d9 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bc24:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 2033ba8 <CSWTCH.2+0x6c8> <== NOT EXECUTED
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
 201bc28:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
 201bc2c:	22 80 00 dc 	be,a   201bf9c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
 201bc30:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
                rtems_rfs_inode_ino (inode), rc, strerror (rc));      
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
 201bc34:	10 80 00 db 	b  201bfa0 <rtems_rfs_dir_lookup_ino+0x4ac>    <== NOT EXECUTED
 201bc38:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      
    while ((rc == 0) && block)                                        
    {                                                                 
      uint8_t* entry;                                                 
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
 201bc3c:	7f ff de b3 	call  2013708 <rtems_rfs_trace>                
 201bc40:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     
 201bc44:	80 8a 20 ff 	btst  0xff, %o0                                
 201bc48:	02 80 00 08 	be  201bc68 <rtems_rfs_dir_lookup_ino+0x174>   <== ALWAYS TAKEN
 201bc4c:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
        printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
 201bc50:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201bc54:	d4 07 bf c0 	ld  [ %fp + -64 ], %o2                         <== NOT EXECUTED
 201bc58:	11 00 80 ce 	sethi  %hi(0x2033800), %o0                     <== NOT EXECUTED
 201bc5c:	40 00 18 ca 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bc60:	90 12 23 e8 	or  %o0, 0x3e8, %o0	! 2033be8 <CSWTCH.2+0x708> <== NOT EXECUTED
                rtems_rfs_inode_ino (inode), map.bpos.bno);           
                                                                      
      rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
 201bc64:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         <== NOT EXECUTED
 201bc68:	90 10 00 10 	mov  %l0, %o0                                  
 201bc6c:	92 07 bf a4 	add  %fp, -92, %o1                             
 201bc70:	7f ff fd e2 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201bc74:	96 10 20 01 	mov  1, %o3                                    
      if (rc > 0)                                                     
 201bc78:	a2 92 20 00 	orcc  %o0, 0, %l1                              
 201bc7c:	04 80 00 15 	ble  201bcd0 <rtems_rfs_dir_lookup_ino+0x1dc>  <== ALWAYS TAKEN
 201bc80:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))         
 201bc84:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201bc88:	7f ff de a0 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201bc8c:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
 201bc90:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201bc94:	22 80 00 c2 	be,a   201bf9c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
 201bc98:	b0 10 00 11 	mov  %l1, %i0                                  <== NOT EXECUTED
          printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
 201bc9c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
 201bca0:	fa 07 bf a0 	ld  [ %fp + -96 ], %i5                         <== NOT EXECUTED
 201bca4:	40 00 1d 24 	call  2023134 <strerror>                       <== NOT EXECUTED
 201bca8:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
 201bcac:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201bcb0:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
 201bcb4:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
 201bcb8:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201bcbc:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
 201bcc0:	40 00 18 b1 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bcc4:	90 12 20 20 	or  %o0, 0x20, %o0                             <== 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;                                                
 201bcc8:	10 80 00 b5 	b  201bf9c <rtems_rfs_dir_lookup_ino+0x4a8>    <== NOT EXECUTED
 201bccc:	b0 10 00 11 	mov  %l1, %i0                                  <== NOT EXECUTED
       * means the entry is empty.                                    
       */                                                             
                                                                      
      entry = rtems_rfs_buffer_data (&entries);                       
                                                                      
      map.bpos.boff = 0;                                              
 201bcd0:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
                                                                      
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
 201bcd4:	10 80 00 71 	b  201be98 <rtems_rfs_dir_lookup_ino+0x3a4>    
 201bcd8:	e4 00 60 1c 	ld  [ %g1 + 0x1c ], %l2                        
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
 201bcdc:	c8 0c a0 04 	ldub  [ %l2 + 4 ], %g4                         
 201bce0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201bce4:	89 29 20 18 	sll  %g4, 0x18, %g4                            
 201bce8:	88 11 00 02 	or  %g4, %g2, %g4                              
 201bcec:	c4 0c a0 07 	ldub  [ %l2 + 7 ], %g2                         
        elength = rtems_rfs_dir_entry_length (entry);                 
 201bcf0:	c6 0c a0 09 	ldub  [ %l2 + 9 ], %g3                         
      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);                    
 201bcf4:	88 11 00 02 	or  %g4, %g2, %g4                              
 201bcf8:	c4 0c a0 06 	ldub  [ %l2 + 6 ], %g2                         
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
 201bcfc:	de 0c 80 00 	ldub  [ %l2 ], %o7                             
      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);                    
 201bd00:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201bd04:	88 11 00 02 	or  %g4, %g2, %g4                              
        elength = rtems_rfs_dir_entry_length (entry);                 
 201bd08:	c4 0c a0 08 	ldub  [ %l2 + 8 ], %g2                         
        *ino = rtems_rfs_dir_entry_ino (entry);                       
 201bd0c:	9f 2b e0 18 	sll  %o7, 0x18, %o7                            
      {                                                               
        uint32_t ehash;                                               
        int      elength;                                             
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
 201bd10:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201bd14:	a6 10 80 03 	or  %g2, %g3, %l3                              
        *ino = rtems_rfs_dir_entry_ino (entry);                       
 201bd18:	c6 0c a0 01 	ldub  [ %l2 + 1 ], %g3                         
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
 201bd1c:	80 a4 c0 14 	cmp  %l3, %l4                                  
        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);                       
 201bd20:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 201bd24:	86 13 c0 03 	or  %o7, %g3, %g3                              
 201bd28:	de 0c a0 03 	ldub  [ %l2 + 3 ], %o7                         
 201bd2c:	86 10 c0 0f 	or  %g3, %o7, %g3                              
 201bd30:	de 0c a0 02 	ldub  [ %l2 + 2 ], %o7                         
 201bd34:	9f 2b e0 08 	sll  %o7, 8, %o7                               
 201bd38:	86 10 c0 0f 	or  %g3, %o7, %g3                              
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
 201bd3c:	12 80 00 07 	bne  201bd58 <rtems_rfs_dir_lookup_ino+0x264>  
 201bd40:	c6 27 00 00 	st  %g3, [ %i4 ]                               
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
 201bd44:	80 a4 60 00 	cmp  %l1, 0                                    
 201bd48:	32 80 00 85 	bne,a   201bf5c <rtems_rfs_dir_lookup_ino+0x468><== NEVER TAKEN
 201bd4c:	b0 10 00 11 	mov  %l1, %i0                                  <== NOT EXECUTED
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
 201bd50:	10 80 00 5a 	b  201beb8 <rtems_rfs_dir_lookup_ino+0x3c4>    
 201bd54:	90 10 00 10 	mov  %l0, %o0                                  
        *ino = rtems_rfs_dir_entry_ino (entry);                       
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
 201bd58:	80 a4 e0 0a 	cmp  %l3, 0xa                                  
 201bd5c:	34 80 00 0a 	bg,a   201bd84 <rtems_rfs_dir_lookup_ino+0x290><== ALWAYS TAKEN
 201bd60:	de 04 20 1c 	ld  [ %l0 + 0x1c ], %o7                        
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
 201bd64:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201bd68:	7f ff de 68 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201bd6c:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
 201bd70:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201bd74:	22 80 00 70 	be,a   201bf34 <rtems_rfs_dir_lookup_ino+0x440><== NOT EXECUTED
 201bd78:	a2 10 20 05 	mov  5, %l1                                    <== NOT EXECUTED
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bd7c:	10 80 00 0c 	b  201bdac <rtems_rfs_dir_lookup_ino+0x2b8>    <== NOT EXECUTED
 201bd80:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
        *ino = rtems_rfs_dir_entry_ino (entry);                       
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
 201bd84:	80 a4 c0 0f 	cmp  %l3, %o7                                  
 201bd88:	1a bf ff f7 	bcc  201bd64 <rtems_rfs_dir_lookup_ino+0x270>  <== NEVER TAKEN
 201bd8c:	80 a0 e0 00 	cmp  %g3, 0                                    
 201bd90:	02 bf ff f6 	be  201bd68 <rtems_rfs_dir_lookup_ino+0x274>   <== NEVER TAKEN
 201bd94:	90 10 20 00 	clr  %o0                                       
 201bd98:	de 04 20 14 	ld  [ %l0 + 0x14 ], %o7                        
 201bd9c:	80 a0 c0 0f 	cmp  %g3, %o7                                  
 201bda0:	08 80 00 0a 	bleu  201bdc8 <rtems_rfs_dir_lookup_ino+0x2d4> <== ALWAYS TAKEN
 201bda4:	c2 07 bf 9c 	ld  [ %fp + -100 ], %g1                        
 201bda8:	30 bf ff f0 	b,a   201bd68 <rtems_rfs_dir_lookup_ino+0x274> <== NOT EXECUTED
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bdac:	d6 07 00 00 	ld  [ %i4 ], %o3                               <== NOT EXECUTED
 201bdb0:	d8 07 bf c4 	ld  [ %fp + -60 ], %o4                         <== NOT EXECUTED
 201bdb4:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
 201bdb8:	40 00 18 73 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bdbc:	94 10 00 13 	mov  %l3, %o2                                  <== 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;                                                
 201bdc0:	10 80 00 5d 	b  201bf34 <rtems_rfs_dir_lookup_ino+0x440>    <== NOT EXECUTED
 201bdc4:	a2 10 20 05 	mov  5, %l1                                    <== NOT EXECUTED
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
 201bdc8:	80 a1 00 01 	cmp  %g4, %g1                                  
 201bdcc:	12 80 00 30 	bne  201be8c <rtems_rfs_dir_lookup_ino+0x398>  
 201bdd0:	c6 07 bf c4 	ld  [ %fp + -60 ], %g3                         
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
 201bdd4:	90 10 20 00 	clr  %o0                                       
 201bdd8:	7f ff de 4c 	call  2013708 <rtems_rfs_trace>                
 201bddc:	13 02 00 00 	sethi  %hi(0x8000000), %o1                     
 201bde0:	80 8a 20 ff 	btst  0xff, %o0                                
 201bde4:	02 80 00 12 	be  201be2c <rtems_rfs_dir_lookup_ino+0x338>   <== ALWAYS TAKEN
 201bde8:	90 04 a0 0a 	add  %l2, 0xa, %o0                             
            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));        
 201bdec:	c6 0c a0 01 	ldub  [ %l2 + 1 ], %g3                         <== NOT EXECUTED
 201bdf0:	da 0c 80 00 	ldub  [ %l2 ], %o5                             <== NOT EXECUTED
 201bdf4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            <== NOT EXECUTED
 201bdf8:	9b 2b 60 18 	sll  %o5, 0x18, %o5                            <== NOT EXECUTED
 201bdfc:	9a 13 40 03 	or  %o5, %g3, %o5                              <== NOT EXECUTED
 201be00:	c6 0c a0 03 	ldub  [ %l2 + 3 ], %g3                         <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201be04:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== 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));        
 201be08:	9a 13 40 03 	or  %o5, %g3, %o5                              <== NOT EXECUTED
 201be0c:	c6 0c a0 02 	ldub  [ %l2 + 2 ], %g3                         <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201be10:	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));        
 201be14:	87 28 e0 08 	sll  %g3, 8, %g3                               <== NOT EXECUTED
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201be18:	90 10 00 15 	mov  %l5, %o0                                  <== NOT EXECUTED
 201be1c:	98 10 00 13 	mov  %l3, %o4                                  <== NOT EXECUTED
 201be20:	40 00 18 59 	call  2021f84 <printf>                         <== NOT EXECUTED
 201be24:	9a 13 40 03 	or  %o5, %g3, %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)
 201be28:	90 04 a0 0a 	add  %l2, 0xa, %o0                             <== NOT EXECUTED
 201be2c:	92 10 00 1a 	mov  %i2, %o1                                  
 201be30:	40 00 17 1e 	call  2021aa8 <memcmp>                         
 201be34:	94 10 00 1b 	mov  %i3, %o2                                  
 201be38:	80 a2 20 00 	cmp  %o0, 0                                    
 201be3c:	12 80 00 14 	bne  201be8c <rtems_rfs_dir_lookup_ino+0x398>  <== NEVER TAKEN
 201be40:	c6 07 bf c4 	ld  [ %fp + -60 ], %g3                         
          {                                                           
            *offset = rtems_rfs_block_map_pos (fs, &map);             
 201be44:	90 10 00 10 	mov  %l0, %o0                                  
 201be48:	7f ff f9 48 	call  201a368 <rtems_rfs_block_get_pos>        
 201be4c:	92 07 bf c0 	add  %fp, -64, %o1                             
                                                                      
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
 201be50:	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);             
 201be54:	d2 27 40 00 	st  %o1, [ %i5 ]                               
                                                                      
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
 201be58:	7f ff de 2c 	call  2013708 <rtems_rfs_trace>                
 201be5c:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
 201be60:	80 8a 20 ff 	btst  0xff, %o0                                
 201be64:	22 80 00 4f 	be,a   201bfa0 <rtems_rfs_dir_lookup_ino+0x4ac><== ALWAYS TAKEN
 201be68:	92 07 bf a4 	add  %fp, -92, %o1                             
              printf ("rtems-rfs: dir-lookup-ino: "                   
 201be6c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201be70:	d4 07 00 00 	ld  [ %i4 ], %o2                               <== NOT EXECUTED
 201be74:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
 201be78:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201be7c:	40 00 18 42 	call  2021f84 <printf>                         <== NOT EXECUTED
 201be80:	90 12 21 18 	or  %o0, 0x118, %o0	! 2033d18 <CSWTCH.2+0x838> <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
                rtems_rfs_inode_ino (inode), rc, strerror (rc));      
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
 201be84:	10 80 00 47 	b  201bfa0 <rtems_rfs_dir_lookup_ino+0x4ac>    <== NOT EXECUTED
 201be88:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
 201be8c:	a4 04 80 13 	add  %l2, %l3, %l2                             
            rtems_rfs_block_map_close (fs, &map);                     
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
 201be90:	86 00 c0 13 	add  %g3, %l3, %g3                             
 201be94:	c6 27 bf c4 	st  %g3, [ %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))
 201be98:	c4 04 20 08 	ld  [ %l0 + 8 ], %g2                           
 201be9c:	c6 07 bf c4 	ld  [ %fp + -60 ], %g3                         
 201bea0:	84 00 bf f6 	add  %g2, -10, %g2                             
 201bea4:	80 a0 c0 02 	cmp  %g3, %g2                                  
 201bea8:	2a bf ff 8d 	bcs,a   201bcdc <rtems_rfs_dir_lookup_ino+0x1e8><== ALWAYS TAKEN
 201beac:	c4 0c a0 05 	ldub  [ %l2 + 5 ], %g2                         
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
 201beb0:	10 bf ff a6 	b  201bd48 <rtems_rfs_dir_lookup_ino+0x254>    <== NOT EXECUTED
 201beb4:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
 201beb8:	92 07 bf b0 	add  %fp, -80, %o1                             
 201bebc:	7f ff fa b0 	call  201a97c <rtems_rfs_block_map_next_block> 
 201bec0:	94 07 bf a0 	add  %fp, -96, %o2                             
        if ((rc > 0) && (rc != ENXIO))                                
 201bec4:	80 a2 20 06 	cmp  %o0, 6                                    
 201bec8:	02 80 00 05 	be  201bedc <rtems_rfs_dir_lookup_ino+0x3e8>   <== ALWAYS TAKEN
 201becc:	b0 10 00 08 	mov  %o0, %i0                                  
 201bed0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201bed4:	14 80 00 07 	bg  201bef0 <rtems_rfs_dir_lookup_ino+0x3fc>   <== NOT EXECUTED
 201bed8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
                    "block map next block failed in ino %" PRIu32 ": %d: %s\n",
                    rtems_rfs_inode_ino (inode), rc, strerror (rc));  
        }                                                             
        if (rc == ENXIO)                                              
 201bedc:	80 a6 20 06 	cmp  %i0, 6                                    
 201bee0:	12 80 00 20 	bne  201bf60 <rtems_rfs_dir_lookup_ino+0x46c>  <== NEVER TAKEN
 201bee4:	80 a6 20 00 	cmp  %i0, 0                                    
          rc = ENOENT;                                                
 201bee8:	10 80 00 11 	b  201bf2c <rtems_rfs_dir_lookup_ino+0x438>    
 201beec:	b0 10 20 02 	mov  2, %i0                                    
      if (rc == 0)                                                    
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
        if ((rc > 0) && (rc != ENXIO))                                
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
 201bef0:	7f ff de 06 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201bef4:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
 201bef8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201befc:	22 bf ff f9 	be,a   201bee0 <rtems_rfs_dir_lookup_ino+0x3ec><== NOT EXECUTED
 201bf00:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bf04:	e2 06 60 08 	ld  [ %i1 + 8 ], %l1                           <== NOT EXECUTED
 201bf08:	40 00 1c 8b 	call  2023134 <strerror>                       <== NOT EXECUTED
 201bf0c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201bf10:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
 201bf14:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201bf18:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
 201bf1c:	40 00 18 1a 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bf20:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
 201bf24:	10 80 00 0f 	b  201bf60 <rtems_rfs_dir_lookup_ino+0x46c>    <== NOT EXECUTED
 201bf28:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
 201bf2c:	10 80 00 25 	b  201bfc0 <rtems_rfs_dir_lookup_ino+0x4cc>    
 201bf30:	a2 10 00 18 	mov  %i0, %l1                                  
            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;                                                
 201bf34:	10 80 00 0a 	b  201bf5c <rtems_rfs_dir_lookup_ino+0x468>    <== NOT EXECUTED
 201bf38:	b0 10 00 11 	mov  %l1, %i0                                  <== NOT EXECUTED
                                                                      
        ehash  = rtems_rfs_dir_entry_hash (entry);                    
        elength = rtems_rfs_dir_entry_length (entry);                 
        *ino = rtems_rfs_dir_entry_ino (entry);                       
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
 201bf3c:	29 00 00 3f 	sethi  %hi(0xfc00), %l4                        
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bf40:	2b 00 80 cf 	sethi  %hi(0x2033c00), %l5                     
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
        if ((rc > 0) && (rc != ENXIO))                                
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bf44:	2d 00 80 cf 	sethi  %hi(0x2033c00), %l6                     
          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: "                     
 201bf48:	2f 00 80 cf 	sethi  %hi(0x2033c00), %l7                     
                                                                      
        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)                     
 201bf4c:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
        }                                                             
                                                                      
        if (ehash == hash)                                            
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bf50:	aa 15 60 b8 	or  %l5, 0xb8, %l5                             
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
        if ((rc > 0) && (rc != ENXIO))                                
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
            printf ("rtems-rfs: dir-lookup-ino: "                     
 201bf54:	ac 15 a1 60 	or  %l6, 0x160, %l6                            
          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: "                     
 201bf58:	ae 15 e0 68 	or  %l7, 0x68, %l7                             
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
 201bf5c:	80 a6 20 00 	cmp  %i0, 0                                    
 201bf60:	12 80 00 17 	bne  201bfbc <rtems_rfs_dir_lookup_ino+0x4c8>  <== NEVER TAKEN
 201bf64:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
 201bf68:	80 a0 60 00 	cmp  %g1, 0                                    
 201bf6c:	12 bf ff 34 	bne  201bc3c <rtems_rfs_dir_lookup_ino+0x148>  <== ALWAYS TAKEN
 201bf70:	90 10 20 00 	clr  %o0                                       
 201bf74:	30 80 00 15 	b,a   201bfc8 <rtems_rfs_dir_lookup_ino+0x4d4> <== NOT EXECUTED
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
      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",
 201bf78:	40 00 1c 6f 	call  2023134 <strerror>                       <== NOT EXECUTED
 201bf7c:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
 201bf80:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201bf84:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201bf88:	94 10 20 05 	mov  5, %o2                                    <== NOT EXECUTED
 201bf8c:	11 00 80 cf 	sethi  %hi(0x2033c00), %o0                     <== NOT EXECUTED
 201bf90:	40 00 17 fd 	call  2021f84 <printf>                         <== NOT EXECUTED
 201bf94:	90 12 21 b0 	or  %o0, 0x1b0, %o0	! 2033db0 <CSWTCH.2+0x8d0> <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
 201bf98:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
                rtems_rfs_inode_ino (inode), rc, strerror (rc));      
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
 201bf9c:	92 07 bf a4 	add  %fp, -92, %o1                             
 201bfa0:	7f ff fe cb 	call  201bacc <rtems_rfs_buffer_handle_close>  
 201bfa4:	90 10 00 10 	mov  %l0, %o0                                  
  rtems_rfs_block_map_close (fs, &map);                               
 201bfa8:	90 10 00 10 	mov  %l0, %o0                                  
 201bfac:	7f ff f9 87 	call  201a5c8 <rtems_rfs_block_map_close>      
 201bfb0:	92 07 bf b0 	add  %fp, -80, %o1                             
 201bfb4:	81 c7 e0 08 	ret                                            
 201bfb8:	81 e8 00 00 	restore                                        
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
 201bfbc:	a2 10 00 18 	mov  %i0, %l1                                  <== 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;                                                
 201bfc0:	10 bf ff f7 	b  201bf9c <rtems_rfs_dir_lookup_ino+0x4a8>    
 201bfc4:	b0 10 00 11 	mov  %l1, %i0                                  
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
 201bfc8:	7f ff dd d0 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201bfcc:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
 201bfd0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201bfd4:	32 bf ff e9 	bne,a   201bf78 <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED
 201bfd8:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
 201bfdc:	10 bf ff f0 	b  201bf9c <rtems_rfs_dir_lookup_ino+0x4a8>    <== NOT EXECUTED
 201bfe0:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &entries);                       
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
 201bfe4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201bfe8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201c770 <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) {
 201c770:	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))                     
 201c774:	90 10 20 00 	clr  %o0                                       
 201c778:	7f ff db e4 	call  2013708 <rtems_rfs_trace>                
 201c77c:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
 201c780:	80 8a 20 ff 	btst  0xff, %o0                                
 201c784:	22 80 00 09 	be,a   201c7a8 <rtems_rfs_dir_read+0x38>       <== ALWAYS TAKEN
 201c788:	c0 27 40 00 	clr  [ %i5 ]                                   
    printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
 201c78c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201c790:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201c794:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 201c798:	90 12 20 d0 	or  %o0, 0xd0, %o0                             <== NOT EXECUTED
 201c79c:	40 00 15 fa 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c7a0:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
 201c7a4:	c0 27 40 00 	clr  [ %i5 ]                                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
 201c7a8:	90 10 00 18 	mov  %i0, %o0                                  
 201c7ac:	92 10 00 19 	mov  %i1, %o1                                  
 201c7b0:	7f ff f7 25 	call  201a444 <rtems_rfs_block_map_open>       
 201c7b4:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
 201c7b8:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201c7bc:	14 80 00 d1 	bg  201cb00 <rtems_rfs_dir_read+0x390>         <== NEVER TAKEN
 201c7c0:	90 10 00 1a 	mov  %i2, %o0                                  
    return rc;                                                        
                                                                      
  if (((rtems_rfs_fs_block_size (fs) -                                
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
 201c7c4:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
 201c7c8:	a2 10 00 10 	mov  %l0, %l1                                  
 201c7cc:	92 10 00 1b 	mov  %i3, %o1                                  
 201c7d0:	a0 10 20 00 	clr  %l0                                       
 201c7d4:	96 10 00 11 	mov  %l1, %o3                                  
 201c7d8:	40 00 48 47 	call  202e8f4 <__moddi3>                       
 201c7dc:	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) -                                
 201c7e0:	92 a4 40 09 	subcc  %l1, %o1, %o1                           
 201c7e4:	90 64 00 08 	subx  %l0, %o0, %o0                            
 201c7e8:	80 a2 20 00 	cmp  %o0, 0                                    
 201c7ec:	34 80 00 17 	bg,a   201c848 <rtems_rfs_dir_read+0xd8>       <== NEVER TAKEN
 201c7f0:	a2 07 bf b0 	add  %fp, -80, %l1                             <== NOT EXECUTED
 201c7f4:	80 a2 20 00 	cmp  %o0, 0                                    
 201c7f8:	12 80 00 06 	bne  201c810 <rtems_rfs_dir_read+0xa0>         <== NEVER TAKEN
 201c7fc:	90 10 00 1a 	mov  %i2, %o0                                  
 201c800:	80 a2 60 0a 	cmp  %o1, 0xa                                  
 201c804:	38 80 00 11 	bgu,a   201c848 <rtems_rfs_dir_read+0xd8>      <== ALWAYS TAKEN
 201c808:	a2 07 bf b0 	add  %fp, -80, %l1                             
        (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
    offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *         
 201c80c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 201c810:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201c814:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 201c818:	40 00 47 4c 	call  202e548 <__divdi3>                       <== NOT EXECUTED
 201c81c:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
 201c820:	86 82 60 01 	addcc  %o1, 1, %g3                             <== NOT EXECUTED
 201c824:	84 42 20 00 	addx  %o0, 0, %g2                              <== NOT EXECUTED
 201c828:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
 201c82c:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
 201c830:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 201c834:	40 00 47 01 	call  202e438 <__muldi3>                       <== NOT EXECUTED
 201c838:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
 201c83c:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
 201c840:	b6 10 00 09 	mov  %o1, %i3                                  <== NOT EXECUTED
              rtems_rfs_fs_block_size (fs));                          
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
 201c844:	a2 07 bf b0 	add  %fp, -80, %l1                             <== NOT EXECUTED
 201c848:	a4 07 bf a0 	add  %fp, -96, %l2                             
 201c84c:	90 10 00 18 	mov  %i0, %o0                                  
 201c850:	92 10 00 11 	mov  %l1, %o1                                  
 201c854:	94 10 00 1a 	mov  %i2, %o2                                  
 201c858:	96 10 00 1b 	mov  %i3, %o3                                  
 201c85c:	7f ff f8 2b 	call  201a908 <rtems_rfs_block_map_seek>       
 201c860:	98 10 00 12 	mov  %l2, %o4                                  
  if (rc > 0)                                                         
 201c864:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201c868:	04 80 00 07 	ble  201c884 <rtems_rfs_dir_read+0x114>        <== ALWAYS TAKEN
 201c86c:	80 a4 20 06 	cmp  %l0, 6                                    
  {                                                                   
    if (rc == ENXIO)                                                  
 201c870:	22 80 00 02 	be,a   201c878 <rtems_rfs_dir_read+0x108>      <== NOT EXECUTED
 201c874:	a0 10 20 02 	mov  2, %l0                                    <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
 201c878:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201c87c:	10 80 00 9f 	b  201caf8 <rtems_rfs_dir_read+0x388>          <== NOT EXECUTED
 201c880:	92 10 00 11 	mov  %l1, %o1                                  <== 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)                         
 201c884:	2b 00 00 3f 	sethi  %hi(0xfc00), %l5                        
    }                                                                 
                                                                      
    *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",
 201c888:	2d 00 80 d0 	sethi  %hi(0x2034000), %l6                     
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201c88c:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
 201c890:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
 201c894:	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)                         
 201c898:	aa 15 63 ff 	or  %l5, 0x3ff, %l5                            
    }                                                                 
                                                                      
    *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",
 201c89c:	ac 15 a1 80 	or  %l6, 0x180, %l6                            
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
 201c8a0:	ae 10 00 11 	mov  %l1, %l7                                  
 201c8a4:	a8 10 00 12 	mov  %l2, %l4                                  
    uint8_t*      entry;                                              
    rtems_rfs_ino eino;                                               
    int           elength;                                            
    int           remaining;                                          
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
 201c8a8:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
 201c8ac:	90 10 00 18 	mov  %i0, %o0                                  
 201c8b0:	92 07 bf a4 	add  %fp, -92, %o1                             
 201c8b4:	7f ff fa d1 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201c8b8:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
 201c8bc:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201c8c0:	04 80 00 04 	ble  201c8d0 <rtems_rfs_dir_read+0x160>        <== ALWAYS TAKEN
 201c8c4:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201c8c8:	10 80 00 88 	b  201cae8 <rtems_rfs_dir_read+0x378>          <== NOT EXECUTED
 201c8cc:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
 201c8d0:	e6 07 bf c4 	ld  [ %fp + -60 ], %l3                         
      rtems_rfs_buffer_handle_close (fs, &buffer);                    
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
 201c8d4:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
    entry += map.bpos.boff;                                           
 201c8d8:	a2 00 40 13 	add  %g1, %l3, %l1                             
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
 201c8dc:	c4 0c 60 09 	ldub  [ %l1 + 9 ], %g2                         
 201c8e0:	e4 0c 60 08 	ldub  [ %l1 + 8 ], %l2                         
    eino    = rtems_rfs_dir_entry_ino (entry);                        
 201c8e4:	c8 08 40 13 	ldub  [ %g1 + %l3 ], %g4                       
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
 201c8e8:	a5 2c a0 08 	sll  %l2, 8, %l2                               
    eino    = rtems_rfs_dir_entry_ino (entry);                        
 201c8ec:	c6 0c 60 01 	ldub  [ %l1 + 1 ], %g3                         
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
 201c8f0:	a4 14 80 02 	or  %l2, %g2, %l2                              
    eino    = rtems_rfs_dir_entry_ino (entry);                        
 201c8f4:	c2 0c 60 02 	ldub  [ %l1 + 2 ], %g1                         
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
 201c8f8:	80 a4 80 15 	cmp  %l2, %l5                                  
 201c8fc:	02 80 00 5d 	be  201ca70 <rtems_rfs_dir_read+0x300>         
 201c900:	c4 0c 60 03 	ldub  [ %l1 + 3 ], %g2                         
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
    entry += map.bpos.boff;                                           
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
    eino    = rtems_rfs_dir_entry_ino (entry);                        
 201c904:	a9 29 20 18 	sll  %g4, 0x18, %l4                            
 201c908:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
 201c90c:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
 201c910:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
 201c914:	82 08 60 ff 	and  %g1, 0xff, %g1                            
 201c918:	a8 15 00 03 	or  %l4, %g3, %l4                              
 201c91c:	83 28 60 08 	sll  %g1, 8, %g1                               
 201c920:	a8 15 00 02 	or  %l4, %g2, %l4                              
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
    {                                                                 
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
 201c924:	80 a4 a0 0a 	cmp  %l2, 0xa                                  
 201c928:	04 80 00 0d 	ble  201c95c <rtems_rfs_dir_read+0x1ec>        <== NEVER TAKEN
 201c92c:	a8 15 00 01 	or  %l4, %g1, %l4                              
 201c930:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
 201c934:	80 a4 80 01 	cmp  %l2, %g1                                  
 201c938:	1a 80 00 0a 	bcc  201c960 <rtems_rfs_dir_read+0x1f0>        <== NEVER TAKEN
 201c93c:	90 10 20 00 	clr  %o0                                       
 201c940:	80 a5 20 00 	cmp  %l4, 0                                    
 201c944:	02 80 00 08 	be  201c964 <rtems_rfs_dir_read+0x1f4>         <== NEVER TAKEN
 201c948:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
 201c94c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
 201c950:	80 a5 00 01 	cmp  %l4, %g1                                  
 201c954:	08 80 00 12 	bleu  201c99c <rtems_rfs_dir_read+0x22c>       <== ALWAYS TAKEN
 201c958:	90 10 00 1c 	mov  %i4, %o0                                  
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))               
 201c95c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201c960:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    <== NOT EXECUTED
 201c964:	7f ff db 69 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201c968:	a0 10 20 05 	mov  5, %l0                                    <== NOT EXECUTED
 201c96c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201c970:	22 80 00 5e 	be,a   201cae8 <rtems_rfs_dir_read+0x378>      <== NOT EXECUTED
 201c974:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-read: "                             
 201c978:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 201c97c:	d8 07 bf c4 	ld  [ %fp + -60 ], %o4                         <== NOT EXECUTED
 201c980:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201c984:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
 201c988:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
 201c98c:	40 00 15 7e 	call  2021f84 <printf>                         <== NOT EXECUTED
 201c990:	90 12 21 00 	or  %o0, 0x100, %o0                            <== NOT EXECUTED
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201c994:	10 80 00 55 	b  201cae8 <rtems_rfs_dir_read+0x378>          <== NOT EXECUTED
 201c998:	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));                     
 201c99c:	92 10 20 00 	clr  %o1                                       
 201c9a0:	40 00 14 fb 	call  2021d8c <memset>                         
 201c9a4:	94 10 21 18 	mov  0x118, %o2                                
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
 201c9a8:	82 10 21 18 	mov  0x118, %g1                                
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
 201c9ac:	f4 3f 20 08 	std  %i2, [ %i4 + 8 ]                          
      dirent->d_reclen = sizeof (struct dirent);                      
 201c9b0:	c2 37 20 10 	sth  %g1, [ %i4 + 0x10 ]                       
                                                                      
      *length += elength;                                             
 201c9b4:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 201c9b8:	82 04 80 01 	add  %l2, %g1, %g1                             
 201c9bc:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                                                                      
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
 201c9c0:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
 201c9c4:	a6 20 80 13 	sub  %g2, %l3, %l3                             
 201c9c8:	a6 24 c0 12 	sub  %l3, %l2, %l3                             
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
 201c9cc:	80 a4 e0 0a 	cmp  %l3, 0xa                                  
 201c9d0:	14 80 00 04 	bg  201c9e0 <rtems_rfs_dir_read+0x270>         <== ALWAYS TAKEN
 201c9d4:	a4 04 bf f6 	add  %l2, -10, %l2                             
        *length += remaining;                                         
 201c9d8:	82 04 c0 01 	add  %l3, %g1, %g1                             <== NOT EXECUTED
 201c9dc:	c2 27 40 00 	st  %g1, [ %i5 ]                               <== NOT EXECUTED
 201c9e0:	80 a4 a0 ff 	cmp  %l2, 0xff                                 
 201c9e4:	34 80 00 02 	bg,a   201c9ec <rtems_rfs_dir_read+0x27c>      <== NEVER TAKEN
 201c9e8:	a4 10 20 ff 	mov  0xff, %l2                                 <== 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);
 201c9ec:	92 04 60 0a 	add  %l1, 0xa, %o1                             
 201c9f0:	94 10 00 12 	mov  %l2, %o2                                  
 201c9f4:	ba 07 20 14 	add  %i4, 0x14, %i5                            
 201c9f8:	40 00 14 56 	call  2021b50 <memcpy>                         
 201c9fc:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
 201ca00:	c4 0c 40 00 	ldub  [ %l1 ], %g2                             
 201ca04:	c2 0c 60 01 	ldub  [ %l1 + 1 ], %g1                         
 201ca08:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201ca0c:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201ca10:	82 10 80 01 	or  %g2, %g1, %g1                              
 201ca14:	c4 0c 60 03 	ldub  [ %l1 + 3 ], %g2                         
      dirent->d_namlen = elength;                                     
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                 
 201ca18:	90 10 20 00 	clr  %o0                                       
      if (elength > NAME_MAX)                                         
        elength = NAME_MAX;                                           
                                                                      
      memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
 201ca1c:	82 10 40 02 	or  %g1, %g2, %g1                              
 201ca20:	c4 0c 60 02 	ldub  [ %l1 + 2 ], %g2                         
      dirent->d_namlen = elength;                                     
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                 
 201ca24:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
      if (elength > NAME_MAX)                                         
        elength = NAME_MAX;                                           
                                                                      
      memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
 201ca28:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201ca2c:	82 10 40 02 	or  %g1, %g2, %g1                              
      dirent->d_namlen = elength;                                     
 201ca30:	e4 37 20 12 	sth  %l2, [ %i4 + 0x12 ]                       
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                 
 201ca34:	7f ff db 35 	call  2013708 <rtems_rfs_trace>                
 201ca38:	c2 27 00 00 	st  %g1, [ %i4 ]                               
 201ca3c:	80 8a 20 ff 	btst  0xff, %o0                                
 201ca40:	22 80 00 2a 	be,a   201cae8 <rtems_rfs_dir_read+0x378>      <== ALWAYS TAKEN
 201ca44:	92 07 bf a4 	add  %fp, -92, %o1                             
        printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
 201ca48:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          <== NOT EXECUTED
 201ca4c:	d6 07 00 00 	ld  [ %i4 ], %o3                               <== NOT EXECUTED
 201ca50:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201ca54:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
 201ca58:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
 201ca5c:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
 201ca60:	40 00 15 49 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ca64:	90 12 21 48 	or  %o0, 0x148, %o0                            <== NOT EXECUTED
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201ca68:	10 80 00 20 	b  201cae8 <rtems_rfs_dir_read+0x378>          <== NOT EXECUTED
 201ca6c:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        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;          
 201ca70:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
 201ca74:	90 10 20 00 	clr  %o0                                       
        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;          
 201ca78:	a6 20 40 13 	sub  %g1, %l3, %l3                             
 201ca7c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
 201ca80:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
        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;          
 201ca84:	a6 00 40 13 	add  %g1, %l3, %l3                             
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
 201ca88:	7f ff db 20 	call  2013708 <rtems_rfs_trace>                
 201ca8c:	e6 27 40 00 	st  %l3, [ %i5 ]                               
 201ca90:	80 8a 20 ff 	btst  0xff, %o0                                
 201ca94:	02 80 00 08 	be  201cab4 <rtems_rfs_dir_read+0x344>         <== ALWAYS TAKEN
 201ca98:	90 10 00 18 	mov  %i0, %o0                                  
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
 201ca9c:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
 201caa0:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
 201caa4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201caa8:	40 00 15 37 	call  2021f84 <printf>                         <== NOT EXECUTED
 201caac:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
 201cab0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201cab4:	92 10 00 17 	mov  %l7, %o1                                  
 201cab8:	7f ff f7 b1 	call  201a97c <rtems_rfs_block_map_next_block> 
 201cabc:	94 10 00 14 	mov  %l4, %o2                                  
    if (rc == ENXIO)                                                  
 201cac0:	80 a2 20 06 	cmp  %o0, 6                                    
 201cac4:	02 80 00 07 	be  201cae0 <rtems_rfs_dir_read+0x370>         <== ALWAYS TAKEN
 201cac8:	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)                                                     
 201cacc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201cad0:	02 bf ff 77 	be  201c8ac <rtems_rfs_dir_read+0x13c>         <== NOT EXECUTED
 201cad4:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         <== NOT EXECUTED
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201cad8:	10 80 00 04 	b  201cae8 <rtems_rfs_dir_read+0x378>          <== NOT EXECUTED
 201cadc:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
      printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
    if (rc == ENXIO)                                                  
      rc = ENOENT;                                                    
 201cae0:	a0 10 20 02 	mov  2, %l0                                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
 201cae4:	92 07 bf a4 	add  %fp, -92, %o1                             
 201cae8:	7f ff fb f9 	call  201bacc <rtems_rfs_buffer_handle_close>  
 201caec:	90 10 00 18 	mov  %i0, %o0                                  
  rtems_rfs_block_map_close (fs, &map);                               
 201caf0:	90 10 00 18 	mov  %i0, %o0                                  
 201caf4:	92 07 bf b0 	add  %fp, -80, %o1                             
 201caf8:	7f ff f6 b4 	call  201a5c8 <rtems_rfs_block_map_close>      
 201cafc:	01 00 00 00 	nop                                            
  return rc;                                                          
}                                                                     
 201cb00:	81 c7 e0 08 	ret                                            
 201cb04:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

0201cd5c <rtems_rfs_file_close>: } int rtems_rfs_file_close (rtems_rfs_file_system* fs, rtems_rfs_file_handle* handle) {
 201cd5c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rrc;                                                            
  int rc;                                                             
                                                                      
  rrc = 0;                                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                   
 201cd60:	90 10 20 10 	mov  0x10, %o0                                 
 201cd64:	7f ff da 69 	call  2013708 <rtems_rfs_trace>                
 201cd68:	92 10 20 00 	clr  %o1                                       
 201cd6c:	80 8a 20 ff 	btst  0xff, %o0                                
 201cd70:	22 80 00 08 	be,a   201cd90 <rtems_rfs_file_close+0x34>     <== ALWAYS TAKEN
 201cd74:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
    printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",        
            handle->shared->inode.ino);                               
 201cd78:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== NOT EXECUTED
  int rc;                                                             
                                                                      
  rrc = 0;                                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                   
    printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",        
 201cd7c:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201cd80:	d2 00 60 14 	ld  [ %g1 + 0x14 ], %o1                        <== NOT EXECUTED
 201cd84:	40 00 14 80 	call  2021f84 <printf>                         <== NOT EXECUTED
 201cd88:	90 12 22 20 	or  %o0, 0x220, %o0                            <== NOT EXECUTED
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
 201cd8c:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        <== NOT EXECUTED
 201cd90:	c2 02 60 08 	ld  [ %o1 + 8 ], %g1                           
 201cd94:	80 a0 60 00 	cmp  %g1, 0                                    
 201cd98:	04 80 00 03 	ble  201cda4 <rtems_rfs_file_close+0x48>       <== NEVER TAKEN
 201cd9c:	82 00 7f ff 	add  %g1, -1, %g1                              
    handle->shared->references--;                                     
 201cda0:	c2 22 60 08 	st  %g1, [ %o1 + 8 ]                           
                                                                      
  if (handle->shared->references == 0)                                
 201cda4:	c2 02 60 08 	ld  [ %o1 + 8 ], %g1                           
 201cda8:	80 a0 60 00 	cmp  %g1, 0                                    
 201cdac:	12 80 00 7e 	bne  201cfa4 <rtems_rfs_file_close+0x248>      <== NEVER TAKEN
 201cdb0:	ba 10 20 00 	clr  %i5                                       
  {                                                                   
    if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))          
 201cdb4:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
 201cdb8:	80 a0 60 00 	cmp  %g1, 0                                    
 201cdbc:	32 80 00 09 	bne,a   201cde0 <rtems_rfs_file_close+0x84>    <== NEVER TAKEN
 201cdc0:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== NOT EXECUTED
      rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);        
 201cdc4:	90 10 00 18 	mov  %i0, %o0                                  
 201cdc8:	7f ff d3 9a 	call  2011c30 <rtems_rfs_inode_load>           
 201cdcc:	92 02 60 0c 	add  %o1, 0xc, %o1                             
                                                                      
    if (rrc == 0)                                                     
 201cdd0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201cdd4:	32 80 00 3f 	bne,a   201ced0 <rtems_rfs_file_close+0x174>   <== NEVER TAKEN
 201cdd8:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        <== NOT EXECUTED
    {                                                                 
      /*                                                              
       * @todo This could be clever and only update if different.     
       */                                                             
      rtems_rfs_inode_set_atime (&handle->shared->inode,              
 201cddc:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 201cde0:	c4 00 60 8c 	ld  [ %g1 + 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);                  
 201cde4:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
 201cde8:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
 201cdec:	c8 28 e0 10 	stb  %g4, [ %g3 + 0x10 ]                       
 201cdf0:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
 201cdf4:	89 30 a0 10 	srl  %g2, 0x10, %g4                            
 201cdf8:	c8 28 e0 11 	stb  %g4, [ %g3 + 0x11 ]                       
 201cdfc:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
 201ce00:	89 30 a0 08 	srl  %g2, 8, %g4                               
 201ce04:	c8 28 e0 12 	stb  %g4, [ %g3 + 0x12 ]                       
 201ce08:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
 201ce0c:	c4 28 e0 13 	stb  %g2, [ %g3 + 0x13 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201ce10:	86 10 20 01 	mov  1, %g3                                    
 201ce14:	c6 28 60 1c 	stb  %g3, [ %g1 + 0x1c ]                       
                                 handle->shared->atime);              
      rtems_rfs_inode_set_mtime (&handle->shared->inode,              
 201ce18:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 201ce1c:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2                        
 */                                                                   
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);                  
 201ce20:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce24:	bb 30 a0 18 	srl  %g2, 0x18, %i5                            
 201ce28:	fa 29 20 14 	stb  %i5, [ %g4 + 0x14 ]                       
 201ce2c:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce30:	bb 30 a0 10 	srl  %g2, 0x10, %i5                            
 201ce34:	fa 29 20 15 	stb  %i5, [ %g4 + 0x15 ]                       
 201ce38:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce3c:	bb 30 a0 08 	srl  %g2, 8, %i5                               
 201ce40:	fa 29 20 16 	stb  %i5, [ %g4 + 0x16 ]                       
 201ce44:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce48:	c4 29 20 17 	stb  %g2, [ %g4 + 0x17 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201ce4c:	c6 28 60 1c 	stb  %g3, [ %g1 + 0x1c ]                       
                                 handle->shared->mtime);              
      rtems_rfs_inode_set_ctime (&handle->shared->inode,              
 201ce50:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 201ce54:	c4 00 60 94 	ld  [ %g1 + 0x94 ], %g2                        
 */                                                                   
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);                  
 201ce58:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce5c:	bb 30 a0 18 	srl  %g2, 0x18, %i5                            
 201ce60:	fa 29 20 18 	stb  %i5, [ %g4 + 0x18 ]                       
 201ce64:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce68:	bb 30 a0 10 	srl  %g2, 0x10, %i5                            
 201ce6c:	fa 29 20 19 	stb  %i5, [ %g4 + 0x19 ]                       
 201ce70:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce74:	bb 30 a0 08 	srl  %g2, 8, %i5                               
 201ce78:	fa 29 20 1a 	stb  %i5, [ %g4 + 0x1a ]                       
 201ce7c:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
 201ce80:	c4 29 20 1b 	stb  %g2, [ %g4 + 0x1b ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201ce84:	c6 28 60 1c 	stb  %g3, [ %g1 + 0x1c ]                       
                                 handle->shared->ctime);              
      if (!rtems_rfs_block_size_equal (&handle->shared->size,         
 201ce88:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 201ce8c:	c4 00 60 84 	ld  [ %g1 + 0x84 ], %g2                        
 201ce90:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
 201ce94:	80 a0 80 03 	cmp  %g2, %g3                                  
 201ce98:	32 80 00 08 	bne,a   201ceb8 <rtems_rfs_file_close+0x15c>   <== NEVER TAKEN
 201ce9c:	c4 20 60 3c 	st  %g2, [ %g1 + 0x3c ]                        <== NOT EXECUTED
 201cea0:	c8 00 60 88 	ld  [ %g1 + 0x88 ], %g4                        
 201cea4:	c6 00 60 40 	ld  [ %g1 + 0x40 ], %g3                        
 201cea8:	80 a1 00 03 	cmp  %g4, %g3                                  
 201ceac:	02 80 00 08 	be  201cecc <rtems_rfs_file_close+0x170>       <== ALWAYS TAKEN
 201ceb0:	ba 10 20 00 	clr  %i5                                       
 */                                                                   
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);                       
 201ceb4:	c4 20 60 3c 	st  %g2, [ %g1 + 0x3c ]                        <== NOT EXECUTED
 201ceb8:	c4 00 60 88 	ld  [ %g1 + 0x88 ], %g2                        <== NOT EXECUTED
  map->dirty = true;                                                  
 201cebc:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,              
                              rtems_rfs_block_size* size)             
{                                                                     
  rtems_rfs_block_copy_size (&map->size, size);                       
 201cec0:	c4 20 60 40 	st  %g2, [ %g1 + 0x40 ]                        <== NOT EXECUTED
  map->dirty = true;                                                  
 201cec4:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
 201cec8:	c4 28 60 34 	stb  %g2, [ %g1 + 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);        
 201cecc:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
 201ced0:	90 10 00 18 	mov  %i0, %o0                                  
 201ced4:	7f ff f5 bd 	call  201a5c8 <rtems_rfs_block_map_close>      
 201ced8:	92 02 60 34 	add  %o1, 0x34, %o1                            
    if (rc > 0)                                                       
 201cedc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201cee0:	04 80 00 14 	ble  201cf30 <rtems_rfs_file_close+0x1d4>      <== ALWAYS TAKEN
 201cee4:	90 10 20 10 	mov  0x10, %o0                                 
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
 201cee8:	7f ff da 08 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201ceec:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201cef0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201cef4:	02 80 00 0d 	be  201cf28 <rtems_rfs_file_close+0x1cc>       <== NOT EXECUTED
 201cef8:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
        printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
                handle->shared->inode.ino, rc, strerror (rc));        
 201cefc:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== 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",
 201cf00:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201cf04:	40 00 18 8c 	call  2023134 <strerror>                       <== NOT EXECUTED
 201cf08:	f6 00 60 14 	ld  [ %g1 + 0x14 ], %i3                        <== NOT EXECUTED
 201cf0c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201cf10:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201cf14:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201cf18:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201cf1c:	40 00 14 1a 	call  2021f84 <printf>                         <== NOT EXECUTED
 201cf20:	90 12 22 48 	or  %o0, 0x248, %o0	! 2034248 <CSWTCH.2+0xd68> <== NOT EXECUTED
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
 201cf24:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
 201cf28:	22 80 00 02 	be,a   201cf30 <rtems_rfs_file_close+0x1d4>    <== NOT EXECUTED
 201cf2c:	ba 10 00 1c 	mov  %i4, %i5                                  <== NOT EXECUTED
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rc = rtems_rfs_inode_close (fs, &handle->shared->inode);          
 201cf30:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
 201cf34:	90 10 00 18 	mov  %i0, %o0                                  
 201cf38:	7f ff d3 dd 	call  2011eac <rtems_rfs_inode_close>          
 201cf3c:	92 02 60 0c 	add  %o1, 0xc, %o1                             
    if (rc > 0)                                                       
 201cf40:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201cf44:	04 80 00 14 	ble  201cf94 <rtems_rfs_file_close+0x238>      <== ALWAYS TAKEN
 201cf48:	90 10 20 10 	mov  0x10, %o0                                 
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
 201cf4c:	7f ff d9 ef 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201cf50:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201cf54:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201cf58:	02 80 00 0d 	be  201cf8c <rtems_rfs_file_close+0x230>       <== NOT EXECUTED
 201cf5c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
        printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
                handle->shared->inode.ino, rc, strerror (rc));        
 201cf60:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== 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",
 201cf64:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201cf68:	40 00 18 73 	call  2023134 <strerror>                       <== NOT EXECUTED
 201cf6c:	f6 00 60 14 	ld  [ %g1 + 0x14 ], %i3                        <== NOT EXECUTED
 201cf70:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201cf74:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201cf78:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201cf7c:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201cf80:	40 00 14 01 	call  2021f84 <printf>                         <== NOT EXECUTED
 201cf84:	90 12 22 88 	or  %o0, 0x288, %o0	! 2034288 <CSWTCH.2+0xda8> <== NOT EXECUTED
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
 201cf88:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
 201cf8c:	22 80 00 02 	be,a   201cf94 <rtems_rfs_file_close+0x238>    <== NOT EXECUTED
 201cf90:	ba 10 00 1c 	mov  %i4, %i5                                  <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
 201cf94:	7f ff ec a1 	call  2018218 <_Chain_Extract>                 
 201cf98:	d0 06 60 1c 	ld  [ %i1 + 0x1c ], %o0                        
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rtems_chain_extract (&handle->shared->link);                      
    free (handle->shared);                                            
 201cf9c:	7f ff ac 12 	call  2007fe4 <free>                           
 201cfa0:	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);                       
 201cfa4:	90 10 00 18 	mov  %i0, %o0                                  
 201cfa8:	7f ff f8 a0 	call  201b228 <rtems_rfs_buffer_handle_release>
 201cfac:	92 06 60 04 	add  %i1, 4, %o1                               
  handle->dirty = false;                                              
 201cfb0:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              
  handle->bnum  = 0;                                                  
 201cfb4:	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)                                                        
 201cfb8:	80 a7 60 00 	cmp  %i5, 0                                    
 201cfbc:	04 80 00 0f 	ble  201cff8 <rtems_rfs_file_close+0x29c>      <== ALWAYS TAKEN
 201cfc0:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                 
 201cfc4:	90 10 20 10 	mov  0x10, %o0                                 <== NOT EXECUTED
 201cfc8:	7f ff d9 d0 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201cfcc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201cfd0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201cfd4:	22 80 00 0a 	be,a   201cffc <rtems_rfs_file_close+0x2a0>    <== NOT EXECUTED
 201cfd8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
 201cfdc:	40 00 18 56 	call  2023134 <strerror>                       <== NOT EXECUTED
 201cfe0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201cfe4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201cfe8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201cfec:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201cff0:	40 00 13 e5 	call  2021f84 <printf>                         <== NOT EXECUTED
 201cff4:	90 12 22 c8 	or  %o0, 0x2c8, %o0	! 20342c8 <CSWTCH.2+0xde8> <== NOT EXECUTED
  }                                                                   
                                                                      
  free (handle);                                                      
 201cff8:	90 10 00 19 	mov  %i1, %o0                                  
 201cffc:	7f ff ab fa 	call  2007fe4 <free>                           
 201d000:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return rrc;                                                         
}                                                                     
 201d004:	81 c7 e0 08 	ret                                            
 201d008:	81 e8 00 00 	restore                                        
                                                                      

0201d230 <rtems_rfs_file_io_end>: int rtems_rfs_file_io_end (rtems_rfs_file_handle* handle, size_t size, bool read) {
 201d230:	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))                      
 201d234:	90 10 20 20 	mov  0x20, %o0                                 
 201d238:	92 10 20 00 	clr  %o1                                       
 201d23c:	7f ff d9 33 	call  2013708 <rtems_rfs_trace>                
 201d240:	ba 10 00 18 	mov  %i0, %i5                                  
 201d244:	80 8a 20 ff 	btst  0xff, %o0                                
 201d248:	22 80 00 0e 	be,a   201d280 <rtems_rfs_file_io_end+0x50>    <== ALWAYS TAKEN
 201d24c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",               
 201d250:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
 201d254:	22 80 00 05 	be,a   201d268 <rtems_rfs_file_io_end+0x38>    <== NOT EXECUTED
 201d258:	13 00 80 d0 	sethi  %hi(0x2034000), %o1                     <== NOT EXECUTED
 201d25c:	13 00 80 cc 	sethi  %hi(0x2033000), %o1                     <== NOT EXECUTED
 201d260:	10 80 00 03 	b  201d26c <rtems_rfs_file_io_end+0x3c>        <== NOT EXECUTED
 201d264:	92 12 60 a8 	or  %o1, 0xa8, %o1	! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
 201d268:	92 12 62 f0 	or  %o1, 0x2f0, %o1                            <== NOT EXECUTED
 201d26c:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201d270:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
 201d274:	40 00 13 44 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d278:	90 12 23 b0 	or  %o0, 0x3b0, %o0                            <== NOT EXECUTED
            read ? "read" : "write", size);                           
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
 201d27c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
 201d280:	80 a0 60 00 	cmp  %g1, 0                                    
 201d284:	02 80 00 1e 	be  201d2fc <rtems_rfs_file_io_end+0xcc>       <== NEVER TAKEN
 201d288:	80 a6 a0 00 	cmp  %i2, 0                                    
  {                                                                   
    if (!read)                                                        
 201d28c:	32 80 00 05 	bne,a   201d2a0 <rtems_rfs_file_io_end+0x70>   
 201d290:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));   
 201d294:	82 10 20 01 	mov  1, %g1                                    
 201d298:	c2 2f 60 04 	stb  %g1, [ %i5 + 4 ]                          
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
 201d29c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 201d2a0:	92 07 60 04 	add  %i5, 4, %o1                               
 201d2a4:	7f ff f7 e1 	call  201b228 <rtems_rfs_buffer_handle_release>
 201d2a8:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                          rtems_rfs_file_buffer (handle));
    if (rc > 0)                                                       
 201d2ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201d2b0:	04 80 00 14 	ble  201d300 <rtems_rfs_file_io_end+0xd0>      <== ALWAYS TAKEN
 201d2b4:	80 a6 a0 00 	cmp  %i2, 0                                    
    {                                                                 
      printf (                                                        
 201d2b8:	22 80 00 05 	be,a   201d2cc <rtems_rfs_file_io_end+0x9c>    <== NOT EXECUTED
 201d2bc:	3b 00 80 d0 	sethi  %hi(0x2034000), %i5                     <== NOT EXECUTED
 201d2c0:	3b 00 80 cc 	sethi  %hi(0x2033000), %i5                     <== NOT EXECUTED
 201d2c4:	10 80 00 03 	b  201d2d0 <rtems_rfs_file_io_end+0xa0>        <== NOT EXECUTED
 201d2c8:	ba 17 60 a8 	or  %i5, 0xa8, %i5	! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
 201d2cc:	ba 17 62 f0 	or  %i5, 0x2f0, %i5                            <== NOT EXECUTED
 201d2d0:	40 00 17 99 	call  2023134 <strerror>                       <== NOT EXECUTED
 201d2d4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201d2d8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201d2dc:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
 201d2e0:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
 201d2e4:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201d2e8:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
 201d2ec:	40 00 13 26 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d2f0:	90 12 23 d8 	or  %o0, 0x3d8, %o0                            <== NOT EXECUTED
        "rtems-rfs: file-io:   end: error on release: %s size=%zu: %d: %s\n",
        read ? "read" : "write", size, rc, strerror (rc));            
                                                                      
      return rc;                                                      
 201d2f4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201d2f8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                       bool                   read)                   
{                                                                     
  bool atime;                                                         
  bool mtime;                                                         
  bool length;                                                        
  int  rc = 0;                                                        
 201d2fc:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
   * increase the block number and adjust the offset.                 
   *                                                                  
   * If we are the last block and the position is past the current size update
   * the size with the new length. The map holds the block count.     
   */                                                                 
  handle->bpos.boff += size;                                          
 201d300:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 201d304:	b2 06 40 01 	add  %i1, %g1, %i1                             
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
 201d308:	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;                                          
 201d30c:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
 201d310:	c4 00 60 98 	ld  [ %g1 + 0x98 ], %g2                        
 201d314:	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 >=                                            
 201d318:	80 a6 40 02 	cmp  %i1, %g2                                  
 201d31c:	0a 80 00 07 	bcs  201d338 <rtems_rfs_file_io_end+0x108>     
 201d320:	80 a6 a0 00 	cmp  %i2, 0                                    
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
  {                                                                   
    handle->bpos.bno++;                                               
 201d324:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
 201d328:	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++;                                               
 201d32c:	86 00 e0 01 	inc  %g3                                       
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
 201d330:	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++;                                               
 201d334:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
 201d338:	12 80 00 19 	bne  201d39c <rtems_rfs_file_io_end+0x16c>     
 201d33c:	84 10 20 00 	clr  %g2                                       
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
 201d340:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
 201d344:	80 a0 e0 00 	cmp  %g3, 0                                    
 201d348:	02 80 00 05 	be  201d35c <rtems_rfs_file_io_end+0x12c>      
 201d34c:	c4 00 60 3c 	ld  [ %g1 + 0x3c ], %g2                        
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
 201d350:	80 a0 a0 00 	cmp  %g2, 0                                    
 201d354:	22 80 00 0f 	be,a   201d390 <rtems_rfs_file_io_end+0x160>   <== NEVER TAKEN
 201d358:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        <== NOT EXECUTED
 201d35c:	80 a0 c0 02 	cmp  %g3, %g2                                  
 201d360:	3a 80 00 0c 	bcc,a   201d390 <rtems_rfs_file_io_end+0x160>  
 201d364:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 201d368:	88 00 bf ff 	add  %g2, -1, %g4                              
 201d36c:	80 a0 c0 04 	cmp  %g3, %g4                                  
 201d370:	12 80 00 0b 	bne  201d39c <rtems_rfs_file_io_end+0x16c>     
 201d374:	84 10 20 00 	clr  %g2                                       
 201d378:	c8 07 60 14 	ld  [ %i5 + 0x14 ], %g4                        
 201d37c:	c6 00 60 40 	ld  [ %g1 + 0x40 ], %g3                        
 201d380:	80 a1 00 03 	cmp  %g4, %g3                                  
 201d384:	28 80 00 07 	bleu,a   201d3a0 <rtems_rfs_file_io_end+0x170> 
 201d388:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
 201d38c:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
 201d390:	c4 20 60 40 	st  %g2, [ %g1 + 0x40 ]                        
  map->dirty = true;                                                  
 201d394:	84 10 20 01 	mov  1, %g2                                    
 201d398:	c4 28 60 34 	stb  %g2, [ %g1 + 0x34 ]                       
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
 201d39c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
 201d3a0:	b8 10 20 00 	clr  %i4                                       
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
 201d3a4:	a2 08 60 01 	and  %g1, 1, %l1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
 201d3a8:	80 88 60 02 	btst  2, %g1                                   
 201d3ac:	a2 1c 60 01 	xor  %l1, 1, %l1                               
 201d3b0:	12 80 00 03 	bne  201d3bc <rtems_rfs_file_io_end+0x18c>     <== NEVER TAKEN
 201d3b4:	a0 10 00 11 	mov  %l1, %l0                                  
 201d3b8:	b8 08 a0 ff 	and  %g2, 0xff, %i4                            
 201d3bc:	b2 0f 20 01 	and  %i4, 1, %i1                               
  length = rtems_rfs_file_update_length (handle) && length;           
 201d3c0:	80 88 60 04 	btst  4, %g1                                   
 201d3c4:	12 80 00 03 	bne  201d3d0 <rtems_rfs_file_io_end+0x1a0>     <== NEVER TAKEN
 201d3c8:	b6 10 20 00 	clr  %i3                                       
 201d3cc:	b6 08 a0 ff 	and  %g2, 0xff, %i3                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
 201d3d0:	90 10 20 20 	mov  0x20, %o0                                 
 201d3d4:	92 10 20 00 	clr  %o1                                       
 201d3d8:	7f ff d8 cc 	call  2013708 <rtems_rfs_trace>                
 201d3dc:	b6 0e e0 01 	and  %i3, 1, %i3                               
 201d3e0:	80 8a 20 ff 	btst  0xff, %o0                                
 201d3e4:	22 80 00 17 	be,a   201d440 <rtems_rfs_file_io_end+0x210>   <== ALWAYS TAKEN
 201d3e8:	b8 17 00 11 	or  %i4, %l1, %i4                              
    printf ("rtems-rfs: file-io:   end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
 201d3ec:	82 0c 20 ff 	and  %l0, 0xff, %g1                            <== NOT EXECUTED
 201d3f0:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
 201d3f4:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        <== NOT EXECUTED
 201d3f8:	96 40 3f ff 	addx  %g0, -1, %o3                             <== NOT EXECUTED
 201d3fc:	82 0e 60 ff 	and  %i1, 0xff, %g1                            <== NOT EXECUTED
 201d400:	d4 07 60 14 	ld  [ %i5 + 0x14 ], %o2                        <== NOT EXECUTED
 201d404:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
 201d408:	82 0e e0 ff 	and  %i3, 0xff, %g1                            <== NOT EXECUTED
 201d40c:	98 40 3f ff 	addx  %g0, -1, %o4                             <== NOT EXECUTED
 201d410:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
 201d414:	96 0a ff ec 	and  %o3, -20, %o3                             <== NOT EXECUTED
 201d418:	98 0b 3f e0 	and  %o4, -32, %o4                             <== NOT EXECUTED
 201d41c:	9a 40 3f ff 	addx  %g0, -1, %o5                             <== NOT EXECUTED
 201d420:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201d424:	9a 0b 7f e1 	and  %o5, -31, %o5                             <== NOT EXECUTED
 201d428:	90 12 20 20 	or  %o0, 0x20, %o0                             <== NOT EXECUTED
 201d42c:	96 02 e0 41 	add  %o3, 0x41, %o3                            <== NOT EXECUTED
 201d430:	98 03 20 4d 	add  %o4, 0x4d, %o4                            <== NOT EXECUTED
 201d434:	40 00 12 d4 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d438:	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)                                                 
 201d43c:	b8 17 00 11 	or  %i4, %l1, %i4                              <== NOT EXECUTED
 201d440:	80 8f 20 01 	btst  1, %i4                                   
 201d444:	02 80 00 13 	be  201d490 <rtems_rfs_file_io_end+0x260>      <== NEVER TAKEN
 201d448:	80 8e e0 ff 	btst  0xff, %i3                                
  {                                                                   
    time_t now = time (NULL);                                         
 201d44c:	40 00 22 ea 	call  2025ff4 <time>                           
 201d450:	90 10 20 00 	clr  %o0                                       
    if (read && atime)                                                
 201d454:	80 a6 a0 00 	cmp  %i2, 0                                    
 201d458:	02 80 00 07 	be  201d474 <rtems_rfs_file_io_end+0x244>      
 201d45c:	80 8e 60 ff 	btst  0xff, %i1                                
 201d460:	80 8c 20 ff 	btst  0xff, %l0                                
 201d464:	02 80 00 04 	be  201d474 <rtems_rfs_file_io_end+0x244>      <== NEVER TAKEN
 201d468:	80 8e 60 ff 	btst  0xff, %i1                                
      handle->shared->atime = now;                                    
 201d46c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 201d470:	d0 20 60 8c 	st  %o0, [ %g1 + 0x8c ]                        
    if (!read && mtime)                                               
 201d474:	02 80 00 07 	be  201d490 <rtems_rfs_file_io_end+0x260>      
 201d478:	80 8e e0 ff 	btst  0xff, %i3                                
 201d47c:	80 a6 a0 01 	cmp  %i2, 1                                    
 201d480:	02 80 00 04 	be  201d490 <rtems_rfs_file_io_end+0x260>      <== NEVER TAKEN
 201d484:	80 8e e0 ff 	btst  0xff, %i3                                
      handle->shared->mtime = now;                                    
 201d488:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 201d48c:	d0 20 60 90 	st  %o0, [ %g1 + 0x90 ]                        
  }                                                                   
  if (length)                                                         
 201d490:	02 80 00 07 	be  201d4ac <rtems_rfs_file_io_end+0x27c>      
 201d494:	01 00 00 00 	nop                                            
  {                                                                   
    handle->shared->size.count =                                      
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
 201d498:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
 201d49c:	c4 00 60 3c 	ld  [ %g1 + 0x3c ], %g2                        
 201d4a0:	c4 20 60 84 	st  %g2, [ %g1 + 0x84 ]                        
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
 201d4a4:	c4 00 60 40 	ld  [ %g1 + 0x40 ], %g2                        
 201d4a8:	c4 20 60 88 	st  %g2, [ %g1 + 0x88 ]                        
      rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));  
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 201d4ac:	81 c7 e0 08 	ret                                            
 201d4b0:	81 e8 00 00 	restore                                        
                                                                      

0201d4b4 <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))
 201d4b4:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
 201d4b8:	80 a0 60 00 	cmp  %g1, 0                                    
 201d4bc:	02 80 00 08 	be  201d4dc <rtems_rfs_file_io_release+0x28>   <== ALWAYS TAKEN
 201d4c0:	92 10 00 08 	mov  %o0, %o1                                  
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
 201d4c4:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        <== NOT EXECUTED
 201d4c8:	92 02 60 04 	add  %o1, 4, %o1                               <== NOT EXECUTED
 201d4cc:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
 201d4d0:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 201d4d4:	7f ff f7 55 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201d4d8:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                          rtems_rfs_file_buffer (handle));
  return rc;                                                          
}                                                                     
 201d4dc:	81 c3 e0 08 	retl                                           
 201d4e0:	90 10 20 00 	clr  %o0                                       
                                                                      

0201d00c <rtems_rfs_file_io_start>: int rtems_rfs_file_io_start (rtems_rfs_file_handle* handle, size_t* available, bool read) {
 201d00c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  size_t size;                                                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
 201d010:	90 10 20 20 	mov  0x20, %o0                                 
 201d014:	92 10 20 00 	clr  %o1                                       
 201d018:	7f ff d9 bc 	call  2013708 <rtems_rfs_trace>                
 201d01c:	ba 10 00 18 	mov  %i0, %i5                                  
 201d020:	80 8a 20 ff 	btst  0xff, %o0                                
 201d024:	22 80 00 0f 	be,a   201d060 <rtems_rfs_file_io_start+0x54>  <== ALWAYS TAKEN
 201d028:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
 201d02c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
 201d030:	22 80 00 05 	be,a   201d044 <rtems_rfs_file_io_start+0x38>  <== NOT EXECUTED
 201d034:	13 00 80 d0 	sethi  %hi(0x2034000), %o1                     <== NOT EXECUTED
 201d038:	13 00 80 cc 	sethi  %hi(0x2033000), %o1                     <== NOT EXECUTED
 201d03c:	10 80 00 03 	b  201d048 <rtems_rfs_file_io_start+0x3c>      <== NOT EXECUTED
 201d040:	92 12 60 a8 	or  %o1, 0xa8, %o1	! 20330a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
 201d044:	92 12 62 f0 	or  %o1, 0x2f0, %o1                            <== NOT EXECUTED
 201d048:	d4 07 60 10 	ld  [ %i5 + 0x10 ], %o2                        <== NOT EXECUTED
 201d04c:	d6 07 60 14 	ld  [ %i5 + 0x14 ], %o3                        <== NOT EXECUTED
 201d050:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201d054:	40 00 13 cc 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d058:	90 12 22 f8 	or  %o0, 0x2f8, %o0	! 20342f8 <CSWTCH.2+0xe18> <== NOT EXECUTED
            read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
                                                                      
  if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))           
 201d05c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
 201d060:	80 a0 60 00 	cmp  %g1, 0                                    
 201d064:	12 80 00 4f 	bne  201d1a0 <rtems_rfs_file_io_start+0x194>   
 201d068:	80 a6 a0 00 	cmp  %i2, 0                                    
    bool                   request_read;                              
    int                    rc;                                        
                                                                      
    request_read = read;                                              
                                                                      
    rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),        
 201d06c:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
 201d070:	94 07 60 10 	add  %i5, 0x10, %o2                            
 201d074:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201d078:	96 07 bf fc 	add  %fp, -4, %o3                              
 201d07c:	7f ff f5 c7 	call  201a798 <rtems_rfs_block_map_find>       
 201d080:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                   rtems_rfs_file_map (handle),       
                                   rtems_rfs_file_bpos (handle),      
                                   &block);                           
    if (rc > 0)                                                       
 201d084:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201d088:	04 80 00 1e 	ble  201d100 <rtems_rfs_file_io_start+0xf4>    
 201d08c:	80 a6 20 06 	cmp  %i0, 6                                    
    {                                                                 
      /*                                                              
       * Has the read reached the EOF ?                               
       */                                                             
      if (read && (rc == ENXIO))                                      
 201d090:	32 80 00 66 	bne,a   201d228 <rtems_rfs_file_io_start+0x21c><== NEVER TAKEN
 201d094:	90 10 20 20 	mov  0x20, %o0                                 <== NOT EXECUTED
 201d098:	80 a6 a0 00 	cmp  %i2, 0                                    
 201d09c:	22 80 00 05 	be,a   201d0b0 <rtems_rfs_file_io_start+0xa4>  <== ALWAYS TAKEN
 201d0a0:	80 a6 20 06 	cmp  %i0, 6                                    
      {                                                               
        *available = 0;                                               
 201d0a4:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
        return 0;                                                     
 201d0a8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201d0ac:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
      }                                                               
                                                                      
      if (rc != ENXIO)                                                
 201d0b0:	12 80 00 5e 	bne  201d228 <rtems_rfs_file_io_start+0x21c>   <== NEVER TAKEN
 201d0b4:	90 10 20 20 	mov  0x20, %o0                                 
        return rc;                                                    
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                  
 201d0b8:	7f ff d9 94 	call  2013708 <rtems_rfs_trace>                
 201d0bc:	92 10 20 00 	clr  %o1                                       
 201d0c0:	80 8a 20 ff 	btst  0xff, %o0                                
 201d0c4:	22 80 00 06 	be,a   201d0dc <rtems_rfs_file_io_start+0xd0>  <== ALWAYS TAKEN
 201d0c8:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
        printf ("rtems-rfs: file-io: start: grow\n");                 
 201d0cc:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201d0d0:	40 00 14 45 	call  20221e4 <puts>                           <== NOT EXECUTED
 201d0d4:	90 12 23 28 	or  %o0, 0x328, %o0	! 2034328 <CSWTCH.2+0xe48> <== NOT EXECUTED
                                                                      
      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),      
 201d0d8:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        <== NOT EXECUTED
 201d0dc:	94 10 20 01 	mov  1, %o2                                    
 201d0e0:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201d0e4:	96 07 bf fc 	add  %fp, -4, %o3                              
 201d0e8:	7f ff f6 32 	call  201a9b0 <rtems_rfs_block_map_grow>       
 201d0ec:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                     rtems_rfs_file_map (handle),     
                                     1, &block);                      
      if (rc > 0)                                                     
 201d0f0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201d0f4:	14 80 00 4d 	bg  201d228 <rtems_rfs_file_io_start+0x21c>    
 201d0f8:	b8 10 20 00 	clr  %i4                                       
 201d0fc:	30 80 00 0f 	b,a   201d138 <rtems_rfs_file_io_start+0x12c>  
      /*                                                              
       * 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 &&                                                    
 201d100:	80 a6 a0 00 	cmp  %i2, 0                                    
 201d104:	12 80 00 0d 	bne  201d138 <rtems_rfs_file_io_start+0x12c>   
 201d108:	b8 10 00 1a 	mov  %i2, %i4                                  
 201d10c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 201d110:	80 a0 60 00 	cmp  %g1, 0                                    
 201d114:	12 80 00 09 	bne  201d138 <rtems_rfs_file_io_start+0x12c>   
 201d118:	b8 10 20 01 	mov  1, %i4                                    
          (rtems_rfs_file_block_offset (handle) ||                    
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
 201d11c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
       * 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) ||                    
 201d120:	c4 06 40 00 	ld  [ %i1 ], %g2                               
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
 201d124:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
       * 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) ||                    
 201d128:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 201d12c:	80 a0 80 01 	cmp  %g2, %g1                                  
 201d130:	3a 80 00 02 	bcc,a   201d138 <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
 201d134:	b8 10 20 00 	clr  %i4                                       <== 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))                    
 201d138:	90 10 20 20 	mov  0x20, %o0                                 
 201d13c:	7f ff d9 73 	call  2013708 <rtems_rfs_trace>                
 201d140:	92 10 20 00 	clr  %o1                                       
 201d144:	80 8a 20 ff 	btst  0xff, %o0                                
 201d148:	22 80 00 0e 	be,a   201d180 <rtems_rfs_file_io_start+0x174> <== ALWAYS TAKEN
 201d14c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
 201d150:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
 201d154:	02 80 00 05 	be  201d168 <rtems_rfs_file_io_start+0x15c>    <== NOT EXECUTED
 201d158:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          <== NOT EXECUTED
 201d15c:	15 00 80 ca 	sethi  %hi(0x2032800), %o2                     <== NOT EXECUTED
 201d160:	10 80 00 04 	b  201d170 <rtems_rfs_file_io_start+0x164>     <== NOT EXECUTED
 201d164:	94 12 a3 28 	or  %o2, 0x328, %o2	! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
 201d168:	15 00 80 c3 	sethi  %hi(0x2030c00), %o2                     <== NOT EXECUTED
 201d16c:	94 12 a0 10 	or  %o2, 0x10, %o2	! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
 201d170:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     <== NOT EXECUTED
 201d174:	40 00 13 84 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d178:	90 12 23 48 	or  %o0, 0x348, %o0	! 2034348 <CSWTCH.2+0xe68> <== NOT EXECUTED
              block, request_read ? "yes" : "no");                    
                                                                      
    rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), 
 201d17c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
 201d180:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
 201d184:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201d188:	92 07 60 04 	add  %i5, 4, %o1                               
 201d18c:	7f ff f8 9b 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201d190:	96 0f 20 ff 	and  %i4, 0xff, %o3                            
                                          rtems_rfs_file_buffer (handle),
                                          block, request_read);       
    if (rc > 0)                                                       
 201d194:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201d198:	14 80 00 24 	bg  201d228 <rtems_rfs_file_io_start+0x21c>    <== NEVER TAKEN
 201d19c:	80 a6 a0 00 	cmp  %i2, 0                                    
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
 201d1a0:	02 80 00 12 	be  201d1e8 <rtems_rfs_file_io_start+0x1dc>    
 201d1a4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
 201d1a8:	c4 00 60 44 	ld  [ %g1 + 0x44 ], %g2                        
 201d1ac:	80 a0 a0 00 	cmp  %g2, 0                                    
 201d1b0:	12 80 00 05 	bne  201d1c4 <rtems_rfs_file_io_start+0x1b8>   
 201d1b4:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
 201d1b8:	80 a0 e0 00 	cmp  %g3, 0                                    
 201d1bc:	22 80 00 07 	be,a   201d1d8 <rtems_rfs_file_io_start+0x1cc> <== NEVER TAKEN
 201d1c0:	f8 00 60 40 	ld  [ %g1 + 0x40 ], %i4                        <== NOT EXECUTED
 201d1c4:	86 00 ff ff 	add  %g3, -1, %g3                              
 201d1c8:	80 a0 80 03 	cmp  %g2, %g3                                  
 201d1cc:	32 80 00 07 	bne,a   201d1e8 <rtems_rfs_file_io_start+0x1dc>
 201d1d0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
 201d1d4:	f8 00 60 40 	ld  [ %g1 + 0x40 ], %i4                        
 201d1d8:	80 a7 20 00 	cmp  %i4, 0                                    
 201d1dc:	32 80 00 06 	bne,a   201d1f4 <rtems_rfs_file_io_start+0x1e8>
 201d1e0:	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));      
 201d1e4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 201d1e8:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
 201d1ec:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
 201d1f0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
 201d1f4:	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);           
 201d1f8:	82 27 00 01 	sub  %i4, %g1, %g1                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
 201d1fc:	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);           
 201d200:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
 201d204:	7f ff d9 41 	call  2013708 <rtems_rfs_trace>                
 201d208:	b0 10 20 00 	clr  %i0                                       
 201d20c:	80 8a 20 ff 	btst  0xff, %o0                                
 201d210:	02 80 00 06 	be  201d228 <rtems_rfs_file_io_start+0x21c>    <== ALWAYS TAKEN
 201d214:	11 00 80 d0 	sethi  %hi(0x2034000), %o0                     
    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",       
 201d218:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 201d21c:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201d220:	40 00 13 59 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d224:	90 12 23 80 	or  %o0, 0x380, %o0                            <== NOT EXECUTED
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
 201d228:	81 c7 e0 08 	ret                                            
 201d22c:	81 e8 00 00 	restore                                        
                                                                      

0201d93c <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) {
 201d93c:	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))                    
 201d940:	90 10 20 08 	mov  8, %o0                                    
 201d944:	7f ff d7 71 	call  2013708 <rtems_rfs_trace>                
 201d948:	92 10 20 00 	clr  %o1                                       
 201d94c:	80 8a 20 ff 	btst  0xff, %o0                                
 201d950:	22 80 00 07 	be,a   201d96c <rtems_rfs_file_open+0x30>      <== ALWAYS TAKEN
 201d954:	c0 26 c0 00 	clr  [ %i3 ]                                   
    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);          
 201d958:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201d95c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201d960:	40 00 11 89 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d964:	90 12 20 a0 	or  %o0, 0xa0, %o0                             <== NOT EXECUTED
                                                                      
  *file = NULL;                                                       
 201d968:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
  /*                                                                  
   * Allocate a new handle and initialise it. Do this before we deal with the
   * shared node data so we do not have to be concerned with reference
   * counting.                                                        
   */                                                                 
  handle = malloc (sizeof (rtems_rfs_file_handle));                   
 201d96c:	90 10 20 20 	mov  0x20, %o0                                 
 201d970:	7f ff ab 2e 	call  2008628 <malloc>                         
 201d974:	a0 10 20 0c 	mov  0xc, %l0                                  
  if (!handle)                                                        
 201d978:	80 a2 20 00 	cmp  %o0, 0                                    
 201d97c:	02 80 00 a4 	be  201dc0c <rtems_rfs_file_open+0x2d0>        <== NEVER TAKEN
 201d980:	ba 10 00 08 	mov  %o0, %i5                                  
    return ENOMEM;                                                    
                                                                      
  memset (handle, 0, sizeof (rtems_rfs_file_handle));                 
 201d984:	92 10 20 00 	clr  %o1                                       
 201d988:	40 00 11 01 	call  2021d8c <memset>                         
 201d98c:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
  /*                                                                  
   * Scan the file system data list of open files for this ino. If found up
   * the reference count and return the pointer to the data.          
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, ino);                       
 201d990:	90 10 00 18 	mov  %i0, %o0                                  
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201d994:	c0 2f 60 04 	clrb  [ %i5 + 4 ]                              
  handle->bnum  = 0;                                                  
 201d998:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  handle->buffer = NULL;                                              
 201d99c:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
 201d9a0:	7f ff ff d9 	call  201d904 <rtems_rfs_file_get_shared>      
 201d9a4:	92 10 00 19 	mov  %i1, %o1                                  
  if (shared)                                                         
 201d9a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201d9ac:	02 80 00 0d 	be  201d9e0 <rtems_rfs_file_open+0xa4>         <== ALWAYS TAKEN
 201d9b0:	90 10 20 08 	mov  8, %o0                                    
  {                                                                   
    shared->references++;                                             
 201d9b4:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           <== NOT EXECUTED
 201d9b8:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
 201d9bc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201d9c0:	7f ff d7 52 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201d9c4:	c2 27 20 08 	st  %g1, [ %i4 + 8 ]                           <== NOT EXECUTED
 201d9c8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201d9cc:	22 80 00 8d 	be,a   201dc00 <rtems_rfs_file_open+0x2c4>     <== NOT EXECUTED
 201d9d0:	f4 27 40 00 	st  %i2, [ %i5 ]                               <== NOT EXECUTED
      printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino); 
 201d9d4:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201d9d8:	10 80 00 87 	b  201dbf4 <rtems_rfs_file_open+0x2b8>         <== NOT EXECUTED
 201d9dc:	90 12 20 c0 	or  %o0, 0xc0, %o0	! 20344c0 <CSWTCH.2+0xfe0>  <== 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));                 
 201d9e0:	7f ff ab 12 	call  2008628 <malloc>                         
 201d9e4:	90 10 20 9c 	mov  0x9c, %o0                                 
    if (!shared)                                                      
 201d9e8:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201d9ec:	12 80 00 04 	bne  201d9fc <rtems_rfs_file_open+0xc0>        <== ALWAYS TAKEN
 201d9f0:	92 10 20 00 	clr  %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);                       
 201d9f4:	10 80 00 34 	b  201dac4 <rtems_rfs_file_open+0x188>         <== NOT EXECUTED
 201d9f8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return ENOMEM;                                                  
    }                                                                 
                                                                      
    memset (shared, 0, sizeof (rtems_rfs_file_shared));               
 201d9fc:	40 00 10 e4 	call  2021d8c <memset>                         
 201da00:	94 10 20 9c 	mov  0x9c, %o2                                 
                                                                      
    rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);        
 201da04:	a2 07 20 0c 	add  %i4, 0xc, %l1                             
 201da08:	90 10 00 18 	mov  %i0, %o0                                  
 201da0c:	92 10 00 19 	mov  %i1, %o1                                  
 201da10:	94 10 00 11 	mov  %l1, %o2                                  
 201da14:	7f ff d0 b4 	call  2011ce4 <rtems_rfs_inode_open>           
 201da18:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
 201da1c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201da20:	04 80 00 0f 	ble  201da5c <rtems_rfs_file_open+0x120>       <== ALWAYS TAKEN
 201da24:	90 10 20 08 	mov  8, %o0                                    
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
 201da28:	7f ff d7 38 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201da2c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201da30:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201da34:	02 80 00 21 	be  201dab8 <rtems_rfs_file_open+0x17c>        <== NOT EXECUTED
 201da38:	01 00 00 00 	nop                                            <== NOT EXECUTED
        printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",  
 201da3c:	40 00 15 be 	call  2023134 <strerror>                       <== NOT EXECUTED
 201da40:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 201da44:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 201da48:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201da4c:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201da50:	40 00 11 4d 	call  2021f84 <printf>                         <== NOT EXECUTED
 201da54:	90 12 20 e8 	or  %o0, 0xe8, %o0	! 20344e8 <CSWTCH.2+0x1008> <== NOT EXECUTED
 201da58:	30 80 00 18 	b,a   201dab8 <rtems_rfs_file_open+0x17c>      <== 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); 
 201da5c:	90 10 00 18 	mov  %i0, %o0                                  
 201da60:	92 10 00 11 	mov  %l1, %o1                                  
 201da64:	7f ff f2 78 	call  201a444 <rtems_rfs_block_map_open>       
 201da68:	94 07 20 34 	add  %i4, 0x34, %o2                            
    if (rc > 0)                                                       
 201da6c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201da70:	04 80 00 1e 	ble  201dae8 <rtems_rfs_file_open+0x1ac>       <== ALWAYS TAKEN
 201da74:	82 10 20 01 	mov  1, %g1                                    
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
 201da78:	90 10 20 08 	mov  8, %o0                                    <== NOT EXECUTED
 201da7c:	7f ff d7 23 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201da80:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 201da84:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201da88:	22 80 00 0a 	be,a   201dab0 <rtems_rfs_file_open+0x174>     <== NOT EXECUTED
 201da8c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
        printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
 201da90:	40 00 15 a9 	call  2023134 <strerror>                       <== NOT EXECUTED
 201da94:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 201da98:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 201da9c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201daa0:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201daa4:	40 00 11 38 	call  2021f84 <printf>                         <== NOT EXECUTED
 201daa8:	90 12 21 20 	or  %o0, 0x120, %o0	! 2034520 <CSWTCH.2+0x1040><== NOT EXECUTED
                rc, strerror (rc));                                   
      rtems_rfs_inode_close (fs, &shared->inode);                     
 201daac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201dab0:	7f ff d0 ff 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201dab4:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
      free (shared);                                                  
 201dab8:	7f ff a9 4b 	call  2007fe4 <free>                           <== NOT EXECUTED
 201dabc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201dac0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201dac4:	7f ff f5 d9 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201dac8:	92 07 60 04 	add  %i5, 4, %o1                               <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
 201dacc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
 201dad0:	c0 2f 60 04 	clrb  [ %i5 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201dad4:	c0 27 60 08 	clr  [ %i5 + 8 ]                               <== NOT EXECUTED
 201dad8:	7f ff a9 43 	call  2007fe4 <free>                           <== NOT EXECUTED
 201dadc:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             <== NOT EXECUTED
      return rc;                                                      
 201dae0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201dae4:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
    }                                                                 
                                                                      
    shared->references = 1;                                           
 201dae8:	c2 27 20 08 	st  %g1, [ %i4 + 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);             
 201daec:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1                        
RTEMS_INLINE_ROUTINE void rtems_chain_append(                         
  rtems_chain_control *the_chain,                                     
  rtems_chain_node    *the_node                                       
)                                                                     
{                                                                     
  _Chain_Append( the_chain, the_node );                               
 201daf0:	90 06 20 74 	add  %i0, 0x74, %o0                            
 201daf4:	c6 08 60 0c 	ldub  [ %g1 + 0xc ], %g3                       
 201daf8:	c4 08 60 0d 	ldub  [ %g1 + 0xd ], %g2                       
 201dafc:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201db00:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201db04:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201db08:	c6 08 60 0f 	ldub  [ %g1 + 0xf ], %g3                       
 201db0c:	92 10 00 1c 	mov  %i4, %o1                                  
 201db10:	84 10 80 03 	or  %g2, %g3, %g2                              
 201db14:	c6 08 60 0e 	ldub  [ %g1 + 0xe ], %g3                       
 201db18:	87 28 e0 08 	sll  %g3, 8, %g3                               
 201db1c:	84 10 80 03 	or  %g2, %g3, %g2                              
    shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
 201db20:	c4 27 20 84 	st  %g2, [ %i4 + 0x84 ]                        
    shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
 201db24:	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);            
 201db28:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
 201db2c:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201db30:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201db34:	c4 27 20 88 	st  %g2, [ %i4 + 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);                   
 201db38:	c6 08 60 10 	ldub  [ %g1 + 0x10 ], %g3                      
 201db3c:	c4 08 60 11 	ldub  [ %g1 + 0x11 ], %g2                      
 201db40:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201db44:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201db48:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201db4c:	c6 08 60 13 	ldub  [ %g1 + 0x13 ], %g3                      
 201db50:	84 10 80 03 	or  %g2, %g3, %g2                              
 201db54:	c6 08 60 12 	ldub  [ %g1 + 0x12 ], %g3                      
 201db58:	87 28 e0 08 	sll  %g3, 8, %g3                               
 201db5c:	84 10 80 03 	or  %g2, %g3, %g2                              
    shared->atime = rtems_rfs_inode_get_atime (&shared->inode);       
 201db60:	c4 27 20 8c 	st  %g2, [ %i4 + 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);                   
 201db64:	c6 08 60 14 	ldub  [ %g1 + 0x14 ], %g3                      
 201db68:	c4 08 60 15 	ldub  [ %g1 + 0x15 ], %g2                      
 201db6c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201db70:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201db74:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201db78:	c6 08 60 17 	ldub  [ %g1 + 0x17 ], %g3                      
 201db7c:	84 10 80 03 	or  %g2, %g3, %g2                              
 201db80:	c6 08 60 16 	ldub  [ %g1 + 0x16 ], %g3                      
 201db84:	87 28 e0 08 	sll  %g3, 8, %g3                               
 201db88:	84 10 80 03 	or  %g2, %g3, %g2                              
    shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);       
 201db8c:	c4 27 20 90 	st  %g2, [ %i4 + 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);                   
 201db90:	c4 08 60 19 	ldub  [ %g1 + 0x19 ], %g2                      
 201db94:	c6 08 60 18 	ldub  [ %g1 + 0x18 ], %g3                      
 201db98:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201db9c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 201dba0:	86 10 c0 02 	or  %g3, %g2, %g3                              
 201dba4:	c4 08 60 1b 	ldub  [ %g1 + 0x1b ], %g2                      
 201dba8:	86 10 c0 02 	or  %g3, %g2, %g3                              
 201dbac:	c4 08 60 1a 	ldub  [ %g1 + 0x1a ], %g2                      
    shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);       
    shared->fs = fs;                                                  
 201dbb0:	f0 27 20 98 	st  %i0, [ %i4 + 0x98 ]                        
 201dbb4:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201dbb8:	82 10 c0 02 	or  %g3, %g2, %g1                              
 201dbbc:	7f ff be 66 	call  200d554 <_Chain_Append>                  
 201dbc0:	c2 27 20 94 	st  %g1, [ %i4 + 0x94 ]                        
                                                                      
    rtems_chain_append (&fs->file_shares, &shared->link);             
                                                                      
    rtems_rfs_inode_unload (fs, &shared->inode, false);               
 201dbc4:	92 10 00 11 	mov  %l1, %o1                                  
 201dbc8:	94 10 20 00 	clr  %o2                                       
 201dbcc:	7f ff d0 7c 	call  2011dbc <rtems_rfs_inode_unload>         
 201dbd0:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
 201dbd4:	90 10 20 08 	mov  8, %o0                                    
 201dbd8:	7f ff d6 cc 	call  2013708 <rtems_rfs_trace>                
 201dbdc:	92 10 20 00 	clr  %o1                                       
 201dbe0:	80 8a 20 ff 	btst  0xff, %o0                                
 201dbe4:	22 80 00 07 	be,a   201dc00 <rtems_rfs_file_open+0x2c4>     <== ALWAYS TAKEN
 201dbe8:	f4 27 40 00 	st  %i2, [ %i5 ]                               
      printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
 201dbec:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201dbf0:	90 12 21 58 	or  %o0, 0x158, %o0	! 2034558 <CSWTCH.2+0x1078><== NOT EXECUTED
 201dbf4:	40 00 10 e4 	call  2021f84 <printf>                         <== NOT EXECUTED
 201dbf8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  handle->flags  = oflag;                                             
 201dbfc:	f4 27 40 00 	st  %i2, [ %i5 ]                               <== NOT EXECUTED
  handle->shared = shared;                                            
 201dc00:	f8 27 60 1c 	st  %i4, [ %i5 + 0x1c ]                        
                                                                      
  *file = handle;                                                     
 201dc04:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
                                                                      
  return 0;                                                           
 201dc08:	a0 10 20 00 	clr  %l0                                       
}                                                                     
 201dc0c:	b0 10 00 10 	mov  %l0, %i0                                  
 201dc10:	81 c7 e0 08 	ret                                            
 201dc14:	81 e8 00 00 	restore                                        
                                                                      

0201d4e4 <rtems_rfs_file_seek>: int rtems_rfs_file_seek (rtems_rfs_file_handle* handle, rtems_rfs_pos pos, rtems_rfs_pos* new_pos) {
 201d4e4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
 201d4e8:	90 10 20 20 	mov  0x20, %o0                                 
 201d4ec:	7f ff d8 87 	call  2013708 <rtems_rfs_trace>                
 201d4f0:	92 10 20 00 	clr  %o1                                       
 201d4f4:	80 8a 20 ff 	btst  0xff, %o0                                
 201d4f8:	22 80 00 08 	be,a   201d518 <rtems_rfs_file_seek+0x34>      <== ALWAYS TAKEN
 201d4fc:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
    printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);          
 201d500:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201d504:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201d508:	90 12 20 58 	or  %o0, 0x58, %o0                             <== NOT EXECUTED
 201d50c:	40 00 12 9e 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d510:	94 10 00 1a 	mov  %i2, %o2                                  <== 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),
 201d514:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
 201d518:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201d51c:	7f ff f3 b2 	call  201a3e4 <rtems_rfs_block_get_size>       
 201d520:	92 02 60 84 	add  %o1, 0x84, %o1                            
 201d524:	80 a6 40 08 	cmp  %i1, %o0                                  
 201d528:	18 80 00 23 	bgu  201d5b4 <rtems_rfs_file_seek+0xd0>        <== NEVER TAKEN
 201d52c:	01 00 00 00 	nop                                            
 201d530:	32 80 00 06 	bne,a   201d548 <rtems_rfs_file_seek+0x64>     <== NEVER TAKEN
 201d534:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        <== NOT EXECUTED
 201d538:	80 a6 80 09 	cmp  %i2, %o1                                  
 201d53c:	18 80 00 1e 	bgu  201d5b4 <rtems_rfs_file_seek+0xd0>        
 201d540:	01 00 00 00 	nop                                            
                                            handle->shared))          
  {                                                                   
    rtems_rfs_file_set_bpos (handle, pos);                            
 201d544:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
 201d548:	b8 06 20 10 	add  %i0, 0x10, %i4                            
 201d54c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201d550:	92 10 00 19 	mov  %i1, %o1                                  
 201d554:	94 10 00 1a 	mov  %i2, %o2                                  
 201d558:	7f ff f3 73 	call  201a324 <rtems_rfs_block_get_bpos>       
 201d55c:	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))          
 201d560:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 201d564:	80 a0 60 00 	cmp  %g1, 0                                    
 201d568:	02 80 00 18 	be  201d5c8 <rtems_rfs_file_seek+0xe4>         
 201d56c:	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),      
 201d570:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
 201d574:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201d578:	96 07 bf fc 	add  %fp, -4, %o3                              
 201d57c:	7f ff f4 87 	call  201a798 <rtems_rfs_block_map_find>       
 201d580:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                     rtems_rfs_file_map (handle),     
                                     rtems_rfs_file_bpos (handle),    
                                     &block);                         
      if (rc > 0)                                                     
 201d584:	80 a2 20 00 	cmp  %o0, 0                                    
 201d588:	14 80 00 13 	bg  201d5d4 <rtems_rfs_file_seek+0xf0>         <== NEVER TAKEN
 201d58c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        return rc;                                                    
      if (rtems_rfs_buffer_bnum (&handle->buffer) != block)           
 201d590:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
 201d594:	80 a0 80 01 	cmp  %g2, %g1                                  
 201d598:	02 80 00 0c 	be  201d5c8 <rtems_rfs_file_seek+0xe4>         <== ALWAYS TAKEN
 201d59c:	92 06 20 04 	add  %i0, 4, %o1                               
      {                                                               
        rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
 201d5a0:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        <== NOT EXECUTED
 201d5a4:	7f ff f7 21 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201d5a8:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
    /*                                                                
     * The seek is outside the current file so release any buffer. A write will
     * extend the file.                                               
     */                                                               
    int rc = rtems_rfs_file_io_release (handle);                      
    if (rc > 0)                                                       
 201d5ac:	10 80 00 05 	b  201d5c0 <rtems_rfs_file_seek+0xdc>          <== NOT EXECUTED
 201d5b0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The seek is outside the current file so release any buffer. A write will
     * extend the file.                                               
     */                                                               
    int rc = rtems_rfs_file_io_release (handle);                      
 201d5b4:	7f ff ff c0 	call  201d4b4 <rtems_rfs_file_io_release>      
 201d5b8:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc > 0)                                                       
 201d5bc:	80 a2 20 00 	cmp  %o0, 0                                    
 201d5c0:	14 80 00 05 	bg  201d5d4 <rtems_rfs_file_seek+0xf0>         <== NEVER TAKEN
 201d5c4:	01 00 00 00 	nop                                            
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
 201d5c8:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
 201d5cc:	f4 26 e0 04 	st  %i2, [ %i3 + 4 ]                           
  return 0;                                                           
 201d5d0:	90 10 20 00 	clr  %o0                                       
}                                                                     
 201d5d4:	81 c7 e0 08 	ret                                            
 201d5d8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0201d5dc <rtems_rfs_file_set_size>: int rtems_rfs_file_set_size (rtems_rfs_file_handle* handle, rtems_rfs_pos new_size) {
 201d5dc:	9d e3 bf 90 	save  %sp, -112, %sp                           
 201d5e0:	ba 10 00 1a 	mov  %i2, %i5                                  
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
 201d5e4:	f4 06 20 1c 	ld  [ %i0 + 0x1c ], %i2                        
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,               
                         rtems_rfs_pos          new_size)             
{                                                                     
 201d5e8:	b6 10 00 18 	mov  %i0, %i3                                  
  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))                      
 201d5ec:	90 10 20 20 	mov  0x20, %o0                                 
 201d5f0:	92 10 20 00 	clr  %o1                                       
 201d5f4:	7f ff d8 45 	call  2013708 <rtems_rfs_trace>                
 201d5f8:	b8 10 00 19 	mov  %i1, %i4                                  
 201d5fc:	80 8a 20 ff 	btst  0xff, %o0                                
 201d600:	02 80 00 07 	be  201d61c <rtems_rfs_file_set_size+0x40>     <== ALWAYS TAKEN
 201d604:	b0 06 a0 34 	add  %i2, 0x34, %i0                            
    printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
 201d608:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201d60c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201d610:	90 12 20 78 	or  %o0, 0x78, %o0                             <== NOT EXECUTED
 201d614:	40 00 12 5c 	call  2021f84 <printf>                         <== NOT EXECUTED
 201d618:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
                                                                      
  size = rtems_rfs_file_size (handle);                                
 201d61c:	d2 06 e0 1c 	ld  [ %i3 + 0x1c ], %o1                        
 201d620:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201d624:	7f ff f3 70 	call  201a3e4 <rtems_rfs_block_get_size>       
 201d628:	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)                                               
 201d62c:	80 a2 00 1c 	cmp  %o0, %i4                                  
 201d630:	12 80 00 07 	bne  201d64c <rtems_rfs_file_set_size+0x70>    <== NEVER TAKEN
 201d634:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
 201d638:	80 a2 40 1d 	cmp  %o1, %i5                                  
 201d63c:	12 80 00 04 	bne  201d64c <rtems_rfs_file_set_size+0x70>    
 201d640:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
      handle->shared->mtime = time (NULL);                            
  }                                                                   
                                                                      
  return 0;                                                           
 201d644:	10 80 00 ad 	b  201d8f8 <rtems_rfs_file_set_size+0x31c>     
 201d648:	90 10 20 00 	clr  %o0                                       
  if (size != new_size)                                               
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
 201d64c:	12 80 00 0a 	bne  201d674 <rtems_rfs_file_set_size+0x98>    
 201d650:	f2 06 e0 1c 	ld  [ %i3 + 0x1c ], %i1                        
    {                                                                 
      rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
 201d654:	d0 06 60 98 	ld  [ %i1 + 0x98 ], %o0                        
 201d658:	7f ff f6 90 	call  201b098 <rtems_rfs_block_map_free_all>   
 201d65c:	92 10 00 18 	mov  %i0, %o1                                  
      if (rc > 0)                                                     
 201d660:	80 a2 20 00 	cmp  %o0, 0                                    
 201d664:	14 80 00 a6 	bg  201d8fc <rtems_rfs_file_set_size+0x320>    <== NEVER TAKEN
 201d668:	b0 10 00 08 	mov  %o0, %i0                                  
          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);    
 201d66c:	10 80 00 97 	b  201d8c8 <rtems_rfs_file_set_size+0x2ec>     
 201d670:	fa 06 e0 1c 	ld  [ %i3 + 0x1c ], %i5                        
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
 201d674:	80 a7 00 08 	cmp  %i4, %o0                                  
 201d678:	38 80 00 09 	bgu,a   201d69c <rtems_rfs_file_set_size+0xc0> <== NEVER TAKEN
 201d67c:	c2 06 60 98 	ld  [ %i1 + 0x98 ], %g1                        <== NOT EXECUTED
 201d680:	80 a7 00 08 	cmp  %i4, %o0                                  
 201d684:	32 80 00 58 	bne,a   201d7e4 <rtems_rfs_file_set_size+0x208><== NEVER TAKEN
 201d688:	e0 06 60 98 	ld  [ %i1 + 0x98 ], %l0                        <== NOT EXECUTED
 201d68c:	80 a7 40 09 	cmp  %i5, %o1                                  
 201d690:	28 80 00 55 	bleu,a   201d7e4 <rtems_rfs_file_set_size+0x208>
 201d694:	e0 06 60 98 	ld  [ %i1 + 0x98 ], %l0                        
        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));
 201d698:	c2 06 60 98 	ld  [ %i1 + 0x98 ], %g1                        
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
 201d69c:	ba a7 40 09 	subcc  %i5, %o1, %i5                           
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
 201d6a0:	f2 00 60 08 	ld  [ %g1 + 8 ], %i1                           
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
 201d6a4:	b8 67 00 08 	subx  %i4, %o0, %i4                            
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
        read_block = false;                                           
 201d6a8:	a2 10 20 00 	clr  %l1                                       
 201d6ac:	a0 10 20 01 	mov  1, %l0                                    
                                                                      
        while (count)                                                 
 201d6b0:	10 80 00 48 	b  201d7d0 <rtems_rfs_file_set_size+0x1f4>     
 201d6b4:	a4 06 e0 04 	add  %i3, 4, %l2                               
          /*                                                          
           * 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);
 201d6b8:	c2 06 a0 3c 	ld  [ %i2 + 0x3c ], %g1                        
 201d6bc:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
 201d6c0:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
 201d6c4:	80 a0 a0 00 	cmp  %g2, 0                                    
 201d6c8:	02 80 00 04 	be  201d6d8 <rtems_rfs_file_set_size+0xfc>     
 201d6cc:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
 201d6d0:	82 00 7f ff 	add  %g1, -1, %g1                              
 201d6d4:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),  
 201d6d8:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
 201d6dc:	92 10 00 18 	mov  %i0, %o1                                  
 201d6e0:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201d6e4:	94 07 bf f4 	add  %fp, -12, %o2                             
 201d6e8:	7f ff f4 2c 	call  201a798 <rtems_rfs_block_map_find>       
 201d6ec:	96 07 bf f0 	add  %fp, -16, %o3                             
                                         map, &bpos, &block);         
          if (rc > 0)                                                 
 201d6f0:	80 a2 20 00 	cmp  %o0, 0                                    
 201d6f4:	14 80 00 0b 	bg  201d720 <rtems_rfs_file_set_size+0x144>    
 201d6f8:	80 a2 20 06 	cmp  %o0, 6                                    
                                           map, 1, &block);           
            if (rc > 0)                                               
              return rc;                                              
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
 201d6fc:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 201d700:	80 a7 20 00 	cmp  %i4, 0                                    
 201d704:	12 80 00 17 	bne  201d760 <rtems_rfs_file_set_size+0x184>   <== NEVER TAKEN
 201d708:	84 26 40 01 	sub  %i1, %g1, %g2                             
 201d70c:	80 a0 80 1d 	cmp  %g2, %i5                                  
 201d710:	38 80 00 10 	bgu,a   201d750 <rtems_rfs_file_set_size+0x174>
 201d714:	b2 00 40 1d 	add  %g1, %i5, %i1                             
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
 201d718:	10 80 00 13 	b  201d764 <rtems_rfs_file_set_size+0x188>     
 201d71c:	c0 26 a0 40 	clr  [ %i2 + 0x40 ]                            
          if (rc > 0)                                                 
          {                                                           
            /*                                                        
             * Have we reached the EOF ?                              
             */                                                       
            if (rc != ENXIO)                                          
 201d720:	12 80 00 76 	bne  201d8f8 <rtems_rfs_file_set_size+0x31c>   <== NEVER TAKEN
 201d724:	92 10 00 18 	mov  %i0, %o1                                  
              return rc;                                              
                                                                      
            rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
 201d728:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
 201d72c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201d730:	94 10 20 01 	mov  1, %o2                                    
 201d734:	7f ff f4 9f 	call  201a9b0 <rtems_rfs_block_map_grow>       
 201d738:	96 07 bf f0 	add  %fp, -16, %o3                             
                                           map, 1, &block);           
            if (rc > 0)                                               
 201d73c:	80 a2 20 00 	cmp  %o0, 0                                    
 201d740:	04 bf ff f0 	ble  201d700 <rtems_rfs_file_set_size+0x124>   <== ALWAYS TAKEN
 201d744:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
    if (rtems_rfs_file_update_mtime (handle))                         
      handle->shared->mtime = time (NULL);                            
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 201d748:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201d74c:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
  map->dirty = true;                                                  
 201d750:	e0 2e a0 34 	stb  %l0, [ %i2 + 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;                                          
 201d754:	f2 26 a0 40 	st  %i1, [ %i2 + 0x40 ]                        
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
          {                                                           
            length = count + bpos.boff;                               
            read_block = true;                                        
 201d758:	10 80 00 04 	b  201d768 <rtems_rfs_file_set_size+0x18c>     
 201d75c:	a2 10 20 01 	mov  1, %l1                                    
 201d760:	c0 26 a0 40 	clr  [ %i2 + 0x40 ]                            <== NOT EXECUTED
  map->dirty = true;                                                  
 201d764:	e0 2e a0 34 	stb  %l0, [ %i2 + 0x34 ]                       
          }                                                           
                                                                      
          /*                                                          
           * Only read the block if the length is not the block size. 
           */                                                         
          rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
 201d768:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
 201d76c:	d4 07 bf f0 	ld  [ %fp + -16 ], %o2                         
 201d770:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201d774:	92 10 00 12 	mov  %l2, %o1                                  
 201d778:	7f ff f7 20 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201d77c:	96 0c 60 01 	and  %l1, 1, %o3                               
                                                rtems_rfs_file_buffer (handle),
                                                block, read_block);   
          if (rc > 0)                                                 
 201d780:	80 a2 20 00 	cmp  %o0, 0                                    
 201d784:	14 80 00 5d 	bg  201d8f8 <rtems_rfs_file_set_size+0x31c>    <== NEVER TAKEN
 201d788:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          
            return rc;                                                
                                                                      
          dst = rtems_rfs_buffer_data (&handle->buffer);              
 201d78c:	c2 06 e0 0c 	ld  [ %i3 + 0xc ], %g1                         
          memset (dst + bpos.boff, 0, length - bpos.boff);            
 201d790:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 201d794:	92 10 20 00 	clr  %o1                                       
 201d798:	90 02 00 0a 	add  %o0, %o2, %o0                             
 201d79c:	40 00 11 7c 	call  2021d8c <memset>                         
 201d7a0:	94 26 40 0a 	sub  %i1, %o2, %o2                             
                                                                      
          rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
 201d7a4:	c2 06 e0 1c 	ld  [ %i3 + 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));
 201d7a8:	e0 2e e0 04 	stb  %l0, [ %i3 + 4 ]                          
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
 201d7ac:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201d7b0:	7f ff f6 9e 	call  201b228 <rtems_rfs_buffer_handle_release>
 201d7b4:	92 10 00 12 	mov  %l2, %o1                                  
                                                rtems_rfs_file_buffer (handle));
          if (rc > 0)                                                 
 201d7b8:	80 a2 20 00 	cmp  %o0, 0                                    
 201d7bc:	14 80 00 4f 	bg  201d8f8 <rtems_rfs_file_set_size+0x31c>    <== NEVER TAKEN
 201d7c0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
            return rc;                                                
                                                                      
          count -= length - bpos.boff;                                
 201d7c4:	82 26 40 01 	sub  %i1, %g1, %g1                             
 201d7c8:	ba a7 40 01 	subcc  %i5, %g1, %i5                           
 201d7cc:	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)                                                 
 201d7d0:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
 201d7d4:	32 bf ff b9 	bne,a   201d6b8 <rtems_rfs_file_set_size+0xdc> 
 201d7d8:	c4 06 a0 40 	ld  [ %i2 + 0x40 ], %g2                        
          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);    
 201d7dc:	10 80 00 3b 	b  201d8c8 <rtems_rfs_file_set_size+0x2ec>     
 201d7e0:	fa 06 e0 1c 	ld  [ %i3 + 0x1c ], %i5                        
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
          rtems_rfs_block_map_count (map) -                           
          (((new_size - 1) /                                          
 201d7e4:	92 87 7f ff 	addcc  %i5, -1, %o1                            
 201d7e8:	e2 04 20 08 	ld  [ %l0 + 8 ], %l1                           
 201d7ec:	90 47 3f ff 	addx  %i4, -1, %o0                             
 201d7f0:	94 10 20 00 	clr  %o2                                       
 201d7f4:	40 00 45 34 	call  202ecc4 <__udivdi3>                      
 201d7f8:	96 10 00 11 	mov  %l1, %o3                                  
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
 201d7fc:	c2 06 a0 3c 	ld  [ %i2 + 0x3c ], %g1                        
 201d800:	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));
 201d804:	90 10 00 1c 	mov  %i4, %o0                                  
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
 201d808:	b0 02 40 01 	add  %o1, %g1, %i0                             
          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));
 201d80c:	94 10 20 00 	clr  %o2                                       
 201d810:	92 10 00 1d 	mov  %i5, %o1                                  
 201d814:	40 00 46 00 	call  202f014 <__umoddi3>                      
 201d818:	96 10 00 11 	mov  %l1, %o3                                  
                                                                      
        if (blocks)                                                   
 201d81c:	80 a6 20 00 	cmp  %i0, 0                                    
 201d820:	12 80 00 0b 	bne  201d84c <rtems_rfs_file_set_size+0x270>   
 201d824:	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),
 201d828:	c4 06 e0 10 	ld  [ %i3 + 0x10 ], %g2                        
 201d82c:	82 10 20 01 	mov  1, %g1                                    
 */                                                                   
static inline void                                                    
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,        
                                     rtems_rfs_block_off  offset)     
{                                                                     
  map->size.offset = offset;                                          
 201d830:	fa 26 a0 40 	st  %i5, [ %i2 + 0x40 ]                        
  map->dirty = true;                                                  
 201d834:	c2 2e a0 34 	stb  %g1, [ %i2 + 0x34 ]                       
 201d838:	80 a0 a0 00 	cmp  %g2, 0                                    
 201d83c:	12 80 00 0d 	bne  201d870 <rtems_rfs_file_set_size+0x294>   
 201d840:	c2 06 a0 3c 	ld  [ %i2 + 0x3c ], %g1                        
 201d844:	10 80 00 0f 	b  201d880 <rtems_rfs_file_set_size+0x2a4>     
 201d848:	80 a0 80 01 	cmp  %g2, %g1                                  
          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),
 201d84c:	90 10 00 10 	mov  %l0, %o0                                  
 201d850:	92 06 60 34 	add  %i1, 0x34, %o1                            
 201d854:	7f ff f5 47 	call  201ad70 <rtems_rfs_block_map_shrink>     
 201d858:	94 10 00 18 	mov  %i0, %o2                                  
                                           rtems_rfs_file_map (handle),
                                           blocks);                   
          if (rc > 0)                                                 
 201d85c:	80 a2 20 00 	cmp  %o0, 0                                    
 201d860:	34 80 00 27 	bg,a   201d8fc <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
 201d864:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
        rtems_rfs_block_map_set_size_offset (map, offset);            
                                                                      
        if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
 201d868:	10 bf ff f1 	b  201d82c <rtems_rfs_file_set_size+0x250>     
 201d86c:	c4 06 e0 10 	ld  [ %i3 + 0x10 ], %g2                        
 201d870:	80 a0 60 00 	cmp  %g1, 0                                    
 201d874:	22 80 00 0e 	be,a   201d8ac <rtems_rfs_file_set_size+0x2d0> <== NEVER TAKEN
 201d878:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        <== NOT EXECUTED
 201d87c:	80 a0 80 01 	cmp  %g2, %g1                                  
 201d880:	3a 80 00 0b 	bcc,a   201d8ac <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
 201d884:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        <== NOT EXECUTED
 201d888:	86 00 7f ff 	add  %g1, -1, %g3                              
 201d88c:	80 a0 80 03 	cmp  %g2, %g3                                  
 201d890:	32 80 00 0e 	bne,a   201d8c8 <rtems_rfs_file_set_size+0x2ec><== NEVER TAKEN
 201d894:	fa 06 e0 1c 	ld  [ %i3 + 0x1c ], %i5                        <== NOT EXECUTED
 201d898:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
 201d89c:	80 a0 80 1d 	cmp  %g2, %i5                                  
 201d8a0:	28 80 00 0a 	bleu,a   201d8c8 <rtems_rfs_file_set_size+0x2ec>
 201d8a4:	fa 06 e0 1c 	ld  [ %i3 + 0x1c ], %i5                        
                                          rtems_rfs_block_map_size (map)))
          rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
 201d8a8:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        
 201d8ac:	fa 26 e0 14 	st  %i5, [ %i3 + 0x14 ]                        
 201d8b0:	80 a7 60 00 	cmp  %i5, 0                                    
 201d8b4:	02 80 00 04 	be  201d8c4 <rtems_rfs_file_set_size+0x2e8>    <== NEVER TAKEN
 201d8b8:	c0 26 e0 18 	clr  [ %i3 + 0x18 ]                            
 201d8bc:	82 00 7f ff 	add  %g1, -1, %g1                              
 201d8c0:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        
                                         rtems_rfs_file_bpos (handle));
      }                                                               
    }                                                                 
                                                                      
    handle->shared->size.count  = rtems_rfs_block_map_count (map);    
 201d8c4:	fa 06 e0 1c 	ld  [ %i3 + 0x1c ], %i5                        
 201d8c8:	c2 06 a0 3c 	ld  [ %i2 + 0x3c ], %g1                        
 201d8cc:	c2 27 60 84 	st  %g1, [ %i5 + 0x84 ]                        
    handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
 201d8d0:	c2 06 a0 40 	ld  [ %i2 + 0x40 ], %g1                        
 201d8d4:	c2 27 60 88 	st  %g1, [ %i5 + 0x88 ]                        
                                                                      
    if (rtems_rfs_file_update_mtime (handle))                         
 201d8d8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 201d8dc:	80 88 60 02 	btst  2, %g1                                   
 201d8e0:	12 80 00 06 	bne  201d8f8 <rtems_rfs_file_set_size+0x31c>   <== NEVER TAKEN
 201d8e4:	90 10 20 00 	clr  %o0                                       
      handle->shared->mtime = time (NULL);                            
 201d8e8:	40 00 21 c3 	call  2025ff4 <time>                           
 201d8ec:	90 10 20 00 	clr  %o0                                       
 201d8f0:	d0 27 60 90 	st  %o0, [ %i5 + 0x90 ]                        
  }                                                                   
                                                                      
  return 0;                                                           
 201d8f4:	90 10 20 00 	clr  %o0                                       
}                                                                     
 201d8f8:	b0 10 00 08 	mov  %o0, %i0                                  
 201d8fc:	81 c7 e0 08 	ret                                            
 201d900:	81 e8 00 00 	restore                                        
                                                                      

020107f0 <rtems_rfs_format>: return rc; } int rtems_rfs_format (const char* name, const rtems_rfs_format_config* config) {
 20107f0:	9d e3 be c0 	save  %sp, -320, %sp                           
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
 20107f4:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
 20107f8:	80 a0 60 00 	cmp  %g1, 0                                    
 20107fc:	22 80 00 07 	be,a   2010818 <rtems_rfs_format+0x28>         <== ALWAYS TAKEN
 2010800:	92 10 20 00 	clr  %o1                                       
    printf ("rtems-rfs: format: %s\n", name);                         
 2010804:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010808:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 201080c:	40 00 45 de 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010810:	90 12 20 48 	or  %o0, 0x48, %o0                             <== NOT EXECUTED
                                                                      
  memset (&fs, 0, sizeof (rtems_rfs_file_system));                    
 2010814:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2010818:	94 10 20 84 	mov  0x84, %o2                                 
 201081c:	40 00 45 5c 	call  2021d8c <memset>                         
 2010820:	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;                                                  
 2010824:	82 07 bf c4 	add  %fp, -60, %g1                             
 2010828:	c2 27 bf c0 	st  %g1, [ %fp + -64 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201082c:	82 07 bf c0 	add  %fp, -64, %g1                             
 2010830:	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;                                                  
 2010834:	82 07 bf d4 	add  %fp, -44, %g1                             
 2010838:	c2 27 bf d0 	st  %g1, [ %fp + -48 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201083c:	82 07 bf d0 	add  %fp, -48, %g1                             
 2010840:	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;                                                  
 2010844:	82 07 bf e4 	add  %fp, -28, %g1                             
 2010848:	c2 27 bf e0 	st  %g1, [ %fp + -32 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201084c:	82 07 bf e0 	add  %fp, -32, %g1                             
 2010850:	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;                                                  
 2010854:	82 07 bf f4 	add  %fp, -12, %g1                             
 2010858:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201085c:	82 07 bf f0 	add  %fp, -16, %g1                             
 2010860:	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;                
 2010864:	82 10 20 05 	mov  5, %g1                                    
 2010868:	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;                             
 201086c:	82 10 20 02 	mov  2, %g1                                    
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
 2010870:	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;                             
 2010874:	c2 27 bf 7c 	st  %g1, [ %fp + -132 ]                        
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
 2010878:	40 00 2b 86 	call  201b690 <rtems_rfs_buffer_open>          
 201087c:	92 07 bf 7c 	add  %fp, -132, %o1                            
  if (rc > 0)                                                         
 2010880:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2010884:	04 80 00 08 	ble  20108a4 <rtems_rfs_format+0xb4>           <== ALWAYS TAKEN
 2010888:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        
  {                                                                   
    printf ("rtems-rfs: format: buffer open failed: %d: %s\n",        
 201088c:	40 00 4a 2a 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010890:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2010894:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2010898:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 201089c:	10 80 03 0e 	b  20114d4 <rtems_rfs_format+0xce4>            <== NOT EXECUTED
 20108a0:	90 12 20 60 	or  %o0, 0x60, %o0	! 2032060 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
 20108a4:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1                        
 20108a8:	80 a0 60 00 	cmp  %g1, 0                                    
 20108ac:	32 80 00 08 	bne,a   20108cc <rtems_rfs_format+0xdc>        <== ALWAYS TAKEN
 20108b0:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  {                                                                   
    printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",       
 20108b4:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 20108b8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 20108bc:	40 00 45 b2 	call  2021f84 <printf>                         <== NOT EXECUTED
 20108c0:	90 12 20 90 	or  %o0, 0x90, %o0                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Check the configuration data.                                    
   */                                                                 
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
 20108c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20108c8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
static bool                                                           
rtems_rfs_check_config (rtems_rfs_file_system*         fs,            
                        const rtems_rfs_format_config* config)        
{                                                                     
  fs->block_size = config->block_size;                                
  if (!fs->block_size)                                                
 20108cc:	80 a0 60 00 	cmp  %g1, 0                                    
 20108d0:	12 80 00 2a 	bne  2010978 <rtems_rfs_format+0x188>          
 20108d4:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        
  {                                                                   
    uint64_t total_size = rtems_rfs_fs_media_size (fs);               
 20108d8:	40 00 34 e3 	call  201dc64 <rtems_rfs_fs_media_size>        
 20108dc:	90 07 bf 7c 	add  %fp, -132, %o0                            
                                                                      
    if (total_size >= GIGS (1))                                       
 20108e0:	80 a2 20 00 	cmp  %o0, 0                                    
 20108e4:	12 80 00 08 	bne  2010904 <rtems_rfs_format+0x114>          <== NEVER TAKEN
 20108e8:	37 00 04 00 	sethi  %hi(0x100000), %i3                      
 20108ec:	03 00 03 ff 	sethi  %hi(0xffc00), %g1                       
 20108f0:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! fffff <PROM_START+0xfffff>
 20108f4:	80 a2 40 01 	cmp  %o1, %g1                                  
 20108f8:	08 80 00 16 	bleu  2010950 <rtems_rfs_format+0x160>         <== ALWAYS TAKEN
 20108fc:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
 2010900:	37 00 04 00 	sethi  %hi(0x100000), %i3                      <== NOT EXECUTED
 2010904:	ba 82 40 1b 	addcc  %o1, %i3, %i5                           <== NOT EXECUTED
 2010908:	83 37 60 14 	srl  %i5, 0x14, %g1                            <== NOT EXECUTED
 201090c:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
        if ((gigs & (1 << b)) != 0)                                   
 2010910:	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);             
 2010914:	b8 42 00 1a 	addx  %o0, %i2, %i4                            <== NOT EXECUTED
 2010918:	85 2f 20 0c 	sll  %i4, 0xc, %g2                             <== NOT EXECUTED
 201091c:	84 10 80 01 	or  %g2, %g1, %g2                              <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
 2010920:	82 10 20 1f 	mov  0x1f, %g1                                 <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
 2010924:	89 28 c0 01 	sll  %g3, %g1, %g4                             <== NOT EXECUTED
 2010928:	80 89 00 02 	btst  %g4, %g2                                 <== NOT EXECUTED
 201092c:	32 80 00 06 	bne,a   2010944 <rtems_rfs_format+0x154>       <== NOT EXECUTED
 2010930:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
                                                                      
    if (total_size >= GIGS (1))                                       
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
 2010934:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
 2010938:	12 bf ff fc 	bne  2010928 <rtems_rfs_format+0x138>          <== NOT EXECUTED
 201093c:	89 28 c0 01 	sll  %g3, %g1, %g4                             <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
          break;                                                      
      fs->block_size = 1 << b;                                        
 2010940:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
 2010944:	83 28 80 01 	sll  %g2, %g1, %g1                             <== NOT EXECUTED
 2010948:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        <== NOT EXECUTED
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
 201094c:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
 2010950:	80 a0 61 ff 	cmp  %g1, 0x1ff                                
 2010954:	18 80 00 05 	bgu  2010968 <rtems_rfs_format+0x178>          <== NEVER TAKEN
 2010958:	c4 07 bf 84 	ld  [ %fp + -124 ], %g2                        
      fs->block_size = 512;                                           
 201095c:	82 10 22 00 	mov  0x200, %g1                                
 2010960:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        
                                                                      
    if (fs->block_size > (4 * 1024))                                  
 2010964:	c4 07 bf 84 	ld  [ %fp + -124 ], %g2                        
 2010968:	03 00 00 04 	sethi  %hi(0x1000), %g1                        
 201096c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2010970:	38 80 00 02 	bgu,a   2010978 <rtems_rfs_format+0x188>       <== NEVER TAKEN
 2010974:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        <== NOT EXECUTED
      fs->block_size = (4 * 1024);                                    
  }                                                                   
                                                                      
  if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)     
 2010978:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        
 201097c:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        
 2010980:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        
 2010984:	90 10 00 1d 	mov  %i5, %o0                                  
 2010988:	40 00 76 00 	call  202e188 <.urem>                          
 201098c:	92 10 00 1c 	mov  %i4, %o1                                  
 2010990:	80 a2 20 00 	cmp  %o0, 0                                    
 2010994:	22 80 00 07 	be,a   20109b0 <rtems_rfs_format+0x1c0>        <== ALWAYS TAKEN
 2010998:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
  {                                                                   
    printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
 201099c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 20109a0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 20109a4:	90 12 20 b8 	or  %o0, 0xb8, %o0                             <== NOT EXECUTED
 20109a8:	10 80 02 cc 	b  20114d8 <rtems_rfs_format+0xce8>            <== NOT EXECUTED
 20109ac:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
            fs->block_size, rtems_rfs_fs_media_block_size (fs));      
    return false;                                                     
  }                                                                   
                                                                      
  fs->group_blocks = config->group_blocks;                            
  if (!fs->group_blocks)                                              
 20109b0:	80 a0 60 00 	cmp  %g1, 0                                    
 20109b4:	02 80 00 04 	be  20109c4 <rtems_rfs_format+0x1d4>           <== ALWAYS TAKEN
 20109b8:	bb 2f 60 03 	sll  %i5, 3, %i5                               
    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;                            
 20109bc:	10 80 00 03 	b  20109c8 <rtems_rfs_format+0x1d8>            <== NOT EXECUTED
 20109c0:	c2 27 bf a4 	st  %g1, [ %fp + -92 ]                         <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * The number of blocks per group is defined by the number of bits in a
     * block.                                                         
     */                                                               
    fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);  
 20109c4:	fa 27 bf a4 	st  %i5, [ %fp + -92 ]                         
  }                                                                   
                                                                      
  if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
 20109c8:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
 20109cc:	80 a0 40 1d 	cmp  %g1, %i5                                  
 20109d0:	08 80 00 04 	bleu  20109e0 <rtems_rfs_format+0x1f0>         <== ALWAYS TAKEN
 20109d4:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
 20109d8:	10 80 01 2f 	b  2010e94 <rtems_rfs_format+0x6a4>            <== NOT EXECUTED
 20109dc:	90 12 20 f8 	or  %o0, 0xf8, %o0	! 20320f8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
    return false;                                                     
  }                                                                   
                                                                      
  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;         
 20109e0:	40 00 34 a1 	call  201dc64 <rtems_rfs_fs_media_size>        
 20109e4:	90 07 bf 7c 	add  %fp, -132, %o0                            
 20109e8:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        
 20109ec:	94 10 20 00 	clr  %o2                                       
 20109f0:	40 00 78 b5 	call  202ecc4 <__udivdi3>                      
 20109f4:	96 10 00 1d 	mov  %i5, %o3                                  
 * 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));  
 20109f8:	b9 2f 60 03 	sll  %i5, 3, %i4                               
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
    return false;                                                     
  }                                                                   
                                                                      
  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;         
 20109fc:	d2 27 bf 80 	st  %o1, [ %fp + -128 ]                        
  /*                                                                  
   * The bits per block sets the upper limit for the number of blocks in a
   * group. The disk will be divided into groups which are the number of bits
   * per block.                                                       
   */                                                                 
  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs), 
 2010a00:	90 10 00 09 	mov  %o1, %o0                                  
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
    return false;                                                     
  }                                                                   
                                                                      
  fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;         
 2010a04:	b6 10 00 09 	mov  %o1, %i3                                  
  /*                                                                  
   * The bits per block sets the upper limit for the number of blocks in a
   * group. The disk will be divided into groups which are the number of bits
   * per block.                                                       
   */                                                                 
  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs), 
 2010a08:	7f ff ff 6f 	call  20107c4 <rtems_rfs_rup_quotient>         
 2010a0c:	92 10 00 1c 	mov  %i4, %o1                                  
                                            rtems_rfs_bits_per_block (fs));
                                                                      
  fs->group_inodes = config->group_inodes;                            
 2010a10:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
  /*                                                                  
   * The bits per block sets the upper limit for the number of blocks in a
   * group. The disk will be divided into groups which are the number of bits
   * per block.                                                       
   */                                                                 
  fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs), 
 2010a14:	d0 27 bf a0 	st  %o0, [ %fp + -96 ]                         
                                            rtems_rfs_bits_per_block (fs));
                                                                      
  fs->group_inodes = config->group_inodes;                            
 2010a18:	c2 27 bf a8 	st  %g1, [ %fp + -88 ]                         
  if (!fs->group_inodes)                                              
 2010a1c:	80 a0 60 00 	cmp  %g1, 0                                    
 2010a20:	12 80 00 14 	bne  2010a70 <rtems_rfs_format+0x280>          <== NEVER TAKEN
 2010a24:	b4 10 00 08 	mov  %o0, %i2                                  
    int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;         
                                                                      
    /*                                                                
     * The number of inodes per group is set as a percentage.         
     */                                                               
    if (config->inode_overhead)                                       
 2010a28:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
 2010a2c:	80 a2 20 00 	cmp  %o0, 0                                    
 2010a30:	22 80 00 02 	be,a   2010a38 <rtems_rfs_format+0x248>        <== ALWAYS TAKEN
 2010a34:	90 10 20 01 	mov  1, %o0                                    
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;          
 2010a38:	7f ff c6 d7 	call  2002594 <.umul>                          
 2010a3c:	92 06 ff ff 	add  %i3, -1, %o1                              
 2010a40:	7f ff c7 0f 	call  200267c <.udiv>                          
 2010a44:	92 10 20 64 	mov  0x64, %o1                                 
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
 2010a48:	7f ff ff 5f 	call  20107c4 <rtems_rfs_rup_quotient>         
 2010a4c:	92 10 00 1a 	mov  %i2, %o1                                  
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
 2010a50:	92 10 20 38 	mov  0x38, %o1                                 
                               int                    percentage)     
{                                                                     
  int blocks;                                                         
  blocks = ((rtems_rfs_fs_blocks (fs) -                               
             RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;          
  blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);          
 2010a54:	b6 10 00 08 	mov  %o0, %i3                                  
  return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
 2010a58:	7f ff c7 09 	call  200267c <.udiv>                          
 2010a5c:	90 10 00 1d 	mov  %i5, %o0                                  
 2010a60:	92 10 00 08 	mov  %o0, %o1                                  
 2010a64:	7f ff c6 cc 	call  2002594 <.umul>                          
 2010a68:	90 10 00 1b 	mov  %i3, %o0                                  
     * The number of inodes per group is set as a percentage.         
     */                                                               
    if (config->inode_overhead)                                       
      inode_overhead = config->inode_overhead;                        
                                                                      
    fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
 2010a6c:	d0 27 bf a8 	st  %o0, [ %fp + -88 ]                         
  }                                                                   
                                                                      
  /*                                                                  
   * 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;
 2010a70:	90 10 00 1d 	mov  %i5, %o0                                  
 2010a74:	7f ff c7 02 	call  200267c <.udiv>                          
 2010a78:	92 10 20 38 	mov  0x38, %o1                                 
 2010a7c:	ba 10 00 08 	mov  %o0, %i5                                  
 2010a80:	d0 27 bf ac 	st  %o0, [ %fp + -84 ]                         
  fs->group_inodes =                                                  
    rtems_rfs_rup_quotient (fs->group_inodes,                         
 2010a84:	d0 07 bf a8 	ld  [ %fp + -88 ], %o0                         
 2010a88:	7f ff ff 4f 	call  20107c4 <rtems_rfs_rup_quotient>         
 2010a8c:	92 10 00 1d 	mov  %i5, %o1                                  
                            fs->inodes_per_block) * fs->inodes_per_block;
 2010a90:	7f ff c6 c1 	call  2002594 <.umul>                          
 2010a94:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
 2010a98:	80 a2 00 1c 	cmp  %o0, %i4                                  
 2010a9c:	38 80 00 03 	bgu,a   2010aa8 <rtems_rfs_format+0x2b8>       <== NEVER TAKEN
 2010aa0:	f8 27 bf a8 	st  %i4, [ %fp + -88 ]                         <== NOT EXECUTED
 2010aa4:	d0 27 bf a8 	st  %o0, [ %fp + -88 ]                         
    fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);  
                                                                      
  fs->max_name_length = config->max_name_length;                      
 2010aa8:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
  if (!fs->max_name_length)                                           
 2010aac:	80 a0 60 00 	cmp  %g1, 0                                    
 2010ab0:	22 80 02 90 	be,a   20114f0 <rtems_rfs_format+0xd00>        <== ALWAYS TAKEN
 2010ab4:	82 10 22 00 	mov  0x200, %g1                                
                            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;                      
 2010ab8:	10 80 02 8f 	b  20114f4 <rtems_rfs_format+0xd04>            <== NOT EXECUTED
 2010abc:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        <== NOT EXECUTED
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
                                                                      
  if (config->verbose)                                                
  {                                                                   
    printf ("rtems-rfs: format: media size = %" PRIu64 "\n",          
 2010ac0:	40 00 34 69 	call  201dc64 <rtems_rfs_fs_media_size>        <== NOT EXECUTED
 2010ac4:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
 2010ac8:	84 10 00 08 	mov  %o0, %g2                                  <== NOT EXECUTED
 2010acc:	86 10 00 09 	mov  %o1, %g3                                  <== NOT EXECUTED
 2010ad0:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010ad4:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
 2010ad8:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
 2010adc:	40 00 45 2a 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010ae0:	90 12 21 28 	or  %o0, 0x128, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_media_size (&fs));                           
    printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",        
 2010ae4:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
 2010ae8:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010aec:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
 2010af0:	40 00 45 25 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010af4:	90 12 21 50 	or  %o0, 0x150, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_media_blocks (&fs));                         
    printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",    
 2010af8:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
 2010afc:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010b00:	d2 00 60 20 	ld  [ %g1 + 0x20 ], %o1                        <== NOT EXECUTED
 2010b04:	40 00 45 20 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010b08:	90 12 21 78 	or  %o0, 0x178, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_media_block_size (&fs));                     
    printf ("rtems-rfs: format: size = %" PRIu64 "\n",                
 2010b0c:	40 00 34 4d 	call  201dc40 <rtems_rfs_fs_size>              <== NOT EXECUTED
 2010b10:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
 2010b14:	84 10 00 08 	mov  %o0, %g2                                  <== NOT EXECUTED
 2010b18:	86 10 00 09 	mov  %o1, %g3                                  <== NOT EXECUTED
 2010b1c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010b20:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
 2010b24:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
 2010b28:	40 00 45 17 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010b2c:	90 12 21 a8 	or  %o0, 0x1a8, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_size (&fs));                                 
    printf ("rtems-rfs: format: blocks = %zu\n",                      
 2010b30:	d2 07 bf 80 	ld  [ %fp + -128 ], %o1                        <== NOT EXECUTED
 2010b34:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010b38:	40 00 45 13 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010b3c:	90 12 21 c8 	or  %o0, 0x1c8, %o0	! 20321c8 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
            rtems_rfs_fs_blocks (&fs));                               
    printf ("rtems-rfs: format: block size = %zu\n",                  
 2010b40:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        <== NOT EXECUTED
 2010b44:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010b48:	40 00 45 0f 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010b4c:	90 12 21 f0 	or  %o0, 0x1f0, %o0	! 20321f0 <_CPU_Trap_slot_template+0x1b8><== NOT EXECUTED
            rtems_rfs_fs_block_size (&fs));                           
    printf ("rtems-rfs: format: bits per block = %u\n",               
 2010b50:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        <== NOT EXECUTED
 2010b54:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010b58:	93 2a 60 03 	sll  %o1, 3, %o1                               <== NOT EXECUTED
 2010b5c:	40 00 45 0a 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010b60:	90 12 22 18 	or  %o0, 0x218, %o0                            <== NOT EXECUTED
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
 2010b64:	92 10 20 38 	mov  0x38, %o1                                 <== NOT EXECUTED
 2010b68:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010b6c:	40 00 45 06 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010b70:	90 12 22 40 	or  %o0, 0x240, %o0	! 2032240 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
 2010b74:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         <== NOT EXECUTED
            fs.group_inodes * fs.group_count,                         
 2010b78:	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",            
 2010b7c:	7f ff c6 86 	call  2002594 <.umul>                          <== NOT EXECUTED
 2010b80:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
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,
                                  rtems_rfs_fs_block_size (fs));      
 2010b84:	f8 07 bf 84 	ld  [ %fp + -124 ], %i4                        <== 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",            
 2010b88:	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,
 2010b8c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 2010b90:	91 2f 60 03 	sll  %i5, 3, %o0                               <== NOT EXECUTED
 2010b94:	bb 2f 60 06 	sll  %i5, 6, %i5                               <== NOT EXECUTED
 2010b98:	7f ff ff 0b 	call  20107c4 <rtems_rfs_rup_quotient>         <== NOT EXECUTED
 2010b9c:	90 27 40 08 	sub  %i5, %o0, %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))
 2010ba0:	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));  
 2010ba4:	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))
 2010ba8:	92 00 7f ff 	add  %g1, -1, %o1                              <== NOT EXECUTED
 2010bac:	80 a7 00 09 	cmp  %i4, %o1                                  <== NOT EXECUTED
 2010bb0:	28 80 00 02 	bleu,a   2010bb8 <rtems_rfs_format+0x3c8>      <== NOT EXECUTED
 2010bb4:	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;                  
 2010bb8:	84 02 20 01 	add  %o0, 1, %g2                               <== NOT EXECUTED
 2010bbc:	87 28 a0 02 	sll  %g2, 2, %g3                               <== NOT EXECUTED
 2010bc0:	89 28 a0 07 	sll  %g2, 7, %g4                               <== NOT EXECUTED
 2010bc4:	86 21 00 03 	sub  %g4, %g3, %g3                             <== NOT EXECUTED
 2010bc8:	90 00 c0 02 	add  %g3, %g2, %o0                             <== NOT EXECUTED
 2010bcc:	7f ff c6 ae 	call  2002684 <.div>                           <== NOT EXECUTED
 2010bd0:	91 2a 20 03 	sll  %o0, 3, %o0                               <== 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",            
 2010bd4:	92 10 20 0a 	mov  0xa, %o1                                  <== NOT EXECUTED
 2010bd8:	7f ff c6 ab 	call  2002684 <.div>                           <== NOT EXECUTED
 2010bdc:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
 2010be0:	92 10 20 0a 	mov  0xa, %o1                                  <== NOT EXECUTED
 2010be4:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
 2010be8:	40 00 75 6a 	call  202e190 <.rem>                           <== NOT EXECUTED
 2010bec:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 2010bf0:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
 2010bf4:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2010bf8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 2010bfc:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010c00:	40 00 44 e1 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010c04:	90 12 22 68 	or  %o0, 0x268, %o0	! 2032268 <_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);      
 2010c08:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         <== NOT EXECUTED
 2010c0c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010c10:	40 00 44 dd 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010c14:	90 12 22 98 	or  %o0, 0x298, %o0	! 2032298 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
    printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
 2010c18:	d2 07 bf a4 	ld  [ %fp + -92 ], %o1                         <== NOT EXECUTED
 2010c1c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010c20:	40 00 44 d9 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010c24:	90 12 22 b8 	or  %o0, 0x2b8, %o0	! 20322b8 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
    printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
 2010c28:	d2 07 bf a8 	ld  [ %fp + -88 ], %o1                         <== NOT EXECUTED
 2010c2c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010c30:	40 00 44 d5 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010c34:	90 12 22 e0 	or  %o0, 0x2e0, %o0	! 20322e0 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
 2010c38:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        <== NOT EXECUTED
 2010c3c:	40 00 2b 35 	call  201b910 <rtems_rfs_buffer_setblksize>    
 2010c40:	90 07 bf 7c 	add  %fp, -132, %o0                            
  if (rc > 0)                                                         
 2010c44:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2010c48:	24 80 00 08 	ble,a   2010c68 <rtems_rfs_format+0x478>       <== ALWAYS TAKEN
 2010c4c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           
  {                                                                   
    printf ("rtems-rfs: format: setting block size failed: %d: %s\n", 
 2010c50:	40 00 49 39 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010c54:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2010c58:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2010c5c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010c60:	10 80 02 1d 	b  20114d4 <rtems_rfs_format+0xce4>            <== NOT EXECUTED
 2010c64:	90 12 23 08 	or  %o0, 0x308, %o0	! 2032308 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
  handle->bnum  = 0;                                                  
 2010c68:	c0 27 bf 34 	clr  [ %fp + -204 ]                            
  handle->buffer = NULL;                                              
 2010c6c:	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);       
 2010c70:	90 07 bf 7c 	add  %fp, -132, %o0                            
 2010c74:	92 07 bf 30 	add  %fp, -208, %o1                            
 2010c78:	94 10 20 00 	clr  %o2                                       
 2010c7c:	40 00 29 df 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 2010c80:	96 10 20 00 	clr  %o3                                       
  if (rc > 0)                                                         
 2010c84:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2010c88:	04 80 00 0a 	ble  2010cb0 <rtems_rfs_format+0x4c0>          <== ALWAYS TAKEN
 2010c8c:	92 07 bf 30 	add  %fp, -208, %o1                            
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2010c90:	7f ff fe c3 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 2010c94:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
    printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",  
 2010c98:	40 00 49 27 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010c9c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2010ca0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2010ca4:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010ca8:	10 80 00 73 	b  2010e74 <rtems_rfs_format+0x684>            <== NOT EXECUTED
 2010cac:	90 12 23 40 	or  %o0, 0x340, %o0	! 2032340 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
 2010cb0:	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));                    
 2010cb4:	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);                               
 2010cb8:	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));                    
 2010cbc:	92 10 20 ff 	mov  0xff, %o1                                 
 2010cc0:	40 00 44 33 	call  2021d8c <memset>                         
 2010cc4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
 2010cc8:	82 10 20 28 	mov  0x28, %g1                                 
 2010ccc:	c2 2f 40 00 	stb  %g1, [ %i5 ]                              
 2010cd0:	82 10 20 09 	mov  9, %g1                                    
 2010cd4:	c2 2f 60 01 	stb  %g1, [ %i5 + 1 ]                          
 2010cd8:	82 10 20 20 	mov  0x20, %g1                                 
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
 2010cdc:	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);           
 2010ce0:	c2 2f 60 02 	stb  %g1, [ %i5 + 2 ]                          
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
 2010ce4:	c0 2f 60 05 	clrb  [ %i5 + 5 ]                              
 2010ce8:	c0 2f 60 06 	clrb  [ %i5 + 6 ]                              
 2010cec:	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);           
 2010cf0:	84 10 20 01 	mov  1, %g2                                    
 2010cf4:	c4 2f 60 03 	stb  %g2, [ %i5 + 3 ]                          
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));    
 2010cf8:	c2 07 bf 80 	ld  [ %fp + -128 ], %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);                 
 2010cfc:	92 07 bf 30 	add  %fp, -208, %o1                            
                                                                      
  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));    
 2010d00:	87 30 60 18 	srl  %g1, 0x18, %g3                            
 2010d04:	c6 2f 60 0c 	stb  %g3, [ %i5 + 0xc ]                        
 2010d08:	87 30 60 10 	srl  %g1, 0x10, %g3                            
 2010d0c:	c2 2f 60 0f 	stb  %g1, [ %i5 + 0xf ]                        
 2010d10:	c6 2f 60 0d 	stb  %g3, [ %i5 + 0xd ]                        
 2010d14:	87 30 60 08 	srl  %g1, 8, %g3                               
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
 2010d18:	c2 0f bf 84 	ldub  [ %fp + -124 ], %g1                      
                                                                      
  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));    
 2010d1c:	c6 2f 60 0e 	stb  %g3, [ %i5 + 0xe ]                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
 2010d20:	c2 2f 60 08 	stb  %g1, [ %i5 + 8 ]                          
 2010d24:	c2 17 bf 84 	lduh  [ %fp + -124 ], %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);                 
 2010d28:	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));
 2010d2c:	c2 2f 60 09 	stb  %g1, [ %i5 + 9 ]                          
 2010d30:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        
 2010d34:	83 30 60 08 	srl  %g1, 8, %g1                               
 2010d38:	c2 2f 60 0a 	stb  %g1, [ %i5 + 0xa ]                        
 2010d3c:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        
 2010d40:	c2 2f 60 0b 	stb  %g1, [ %i5 + 0xb ]                        
  write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);          
 2010d44:	c2 0f bf 94 	ldub  [ %fp + -108 ], %g1                      
 2010d48:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
 2010d4c:	c2 17 bf 94 	lduh  [ %fp + -108 ], %g1                      
 2010d50:	c2 2f 60 11 	stb  %g1, [ %i5 + 0x11 ]                       
 2010d54:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 2010d58:	83 30 60 08 	srl  %g1, 8, %g1                               
 2010d5c:	c2 2f 60 12 	stb  %g1, [ %i5 + 0x12 ]                       
 2010d60:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 2010d64:	c2 2f 60 13 	stb  %g1, [ %i5 + 0x13 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
 2010d68:	c2 0f bf 98 	ldub  [ %fp + -104 ], %g1                      
 2010d6c:	c2 2f 60 14 	stb  %g1, [ %i5 + 0x14 ]                       
 2010d70:	c2 17 bf 98 	lduh  [ %fp + -104 ], %g1                      
 2010d74:	c2 2f 60 15 	stb  %g1, [ %i5 + 0x15 ]                       
 2010d78:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
 2010d7c:	83 30 60 08 	srl  %g1, 8, %g1                               
 2010d80:	c2 2f 60 16 	stb  %g1, [ %i5 + 0x16 ]                       
 2010d84:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
 2010d88:	c2 2f 60 17 	stb  %g1, [ %i5 + 0x17 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);             
 2010d8c:	c2 0f bf a0 	ldub  [ %fp + -96 ], %g1                       
 2010d90:	c2 2f 60 18 	stb  %g1, [ %i5 + 0x18 ]                       
 2010d94:	c2 17 bf a0 	lduh  [ %fp + -96 ], %g1                       
 2010d98:	c2 2f 60 19 	stb  %g1, [ %i5 + 0x19 ]                       
 2010d9c:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
 2010da0:	83 30 60 08 	srl  %g1, 8, %g1                               
 2010da4:	c2 2f 60 1a 	stb  %g1, [ %i5 + 0x1a ]                       
 2010da8:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
 2010dac:	c2 2f 60 1b 	stb  %g1, [ %i5 + 0x1b ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);      
 2010db0:	c2 0f bf a4 	ldub  [ %fp + -92 ], %g1                       
 2010db4:	c2 2f 60 1c 	stb  %g1, [ %i5 + 0x1c ]                       
 2010db8:	c2 17 bf a4 	lduh  [ %fp + -92 ], %g1                       
 2010dbc:	c2 2f 60 1d 	stb  %g1, [ %i5 + 0x1d ]                       
 2010dc0:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
 2010dc4:	83 30 60 08 	srl  %g1, 8, %g1                               
 2010dc8:	c2 2f 60 1e 	stb  %g1, [ %i5 + 0x1e ]                       
 2010dcc:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
 2010dd0:	c2 2f 60 1f 	stb  %g1, [ %i5 + 0x1f ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
 2010dd4:	c2 0f bf a8 	ldub  [ %fp + -88 ], %g1                       
 2010dd8:	c2 2f 60 20 	stb  %g1, [ %i5 + 0x20 ]                       
 2010ddc:	c2 17 bf a8 	lduh  [ %fp + -88 ], %g1                       
 2010de0:	c2 2f 60 21 	stb  %g1, [ %i5 + 0x21 ]                       
 2010de4:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
 2010de8:	83 30 60 08 	srl  %g1, 8, %g1                               
 2010dec:	c2 2f 60 22 	stb  %g1, [ %i5 + 0x22 ]                       
 2010df0:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
 2010df4:	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);      
 2010df8:	c2 2f 60 23 	stb  %g1, [ %i5 + 0x23 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
 2010dfc:	c0 2f 60 25 	clrb  [ %i5 + 0x25 ]                           
 2010e00:	c0 2f 60 26 	clrb  [ %i5 + 0x26 ]                           
 2010e04:	82 10 20 38 	mov  0x38, %g1                                 
 2010e08:	c2 2f 60 27 	stb  %g1, [ %i5 + 0x27 ]                       
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  rc = rtems_rfs_buffer_handle_release (fs, &handle);                 
 2010e0c:	40 00 29 07 	call  201b228 <rtems_rfs_buffer_handle_release>
 2010e10:	c4 2f bf 30 	stb  %g2, [ %fp + -208 ]                       
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2010e14:	92 07 bf 30 	add  %fp, -208, %o1                            
  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);                 
 2010e18:	ba 10 00 08 	mov  %o0, %i5                                  
  if (rc > 0)                                                         
 2010e1c:	80 a7 60 00 	cmp  %i5, 0                                    
 2010e20:	04 80 00 0a 	ble  2010e48 <rtems_rfs_format+0x658>          <== ALWAYS TAKEN
 2010e24:	90 07 bf 7c 	add  %fp, -132, %o0                            
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2010e28:	7f ff fe 5d 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 2010e2c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
 2010e30:	40 00 48 c1 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010e34:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2010e38:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2010e3c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010e40:	10 80 00 0d 	b  2010e74 <rtems_rfs_format+0x684>            <== NOT EXECUTED
 2010e44:	90 12 23 78 	or  %o0, 0x378, %o0	! 2032378 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
 2010e48:	7f ff fe 55 	call  201079c <rtems_rfs_buffer_handle_close>  
 2010e4c:	01 00 00 00 	nop                                            
    printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  return true;                                                        
 2010e50:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
  if (rc > 0)                                                         
 2010e54:	80 a2 20 00 	cmp  %o0, 0                                    
 2010e58:	04 80 00 0a 	ble  2010e80 <rtems_rfs_format+0x690>          <== ALWAYS TAKEN
 2010e5c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
 2010e60:	40 00 48 b5 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010e64:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2010e68:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2010e6c:	11 00 80 c8 	sethi  %hi(0x2032000), %o0                     <== NOT EXECUTED
 2010e70:	90 12 23 b8 	or  %o0, 0x3b8, %o0	! 20323b8 <_CPU_Trap_slot_template+0x380><== NOT EXECUTED
 2010e74:	40 00 44 44 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010e78:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
 2010e7c:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
    printf ("rtems-rfs: format: setting block size failed: %d: %s\n", 
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
 2010e80:	80 88 60 ff 	btst  0xff, %g1                                
 2010e84:	12 80 00 f3 	bne  2011250 <rtems_rfs_format+0xa60>          <== ALWAYS TAKEN
 2010e88:	ba 10 20 00 	clr  %i5                                       
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
 2010e8c:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2010e90:	90 12 20 00 	mov  %o0, %o0	! 2032400 <_CPU_Trap_slot_template+0x3c8><== NOT EXECUTED
 2010e94:	40 00 44 d4 	call  20221e4 <puts>                           <== NOT EXECUTED
 2010e98:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2010e9c:	30 80 01 93 	b,a   20114e8 <rtems_rfs_format+0xcf8>         <== NOT EXECUTED
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
 2010ea0:	f8 07 bf a4 	ld  [ %fp + -92 ], %i4                         
 2010ea4:	90 10 00 1d 	mov  %i5, %o0                                  
 2010ea8:	7f ff c5 bb 	call  2002594 <.umul>                          
 2010eac:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
 2010eb0:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        
  size_t                   group_size;                                
  int                      blocks;                                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
 2010eb4:	a0 02 20 01 	add  %o0, 1, %l0                               
    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,                           
 2010eb8:	ec 0e 60 14 	ldub  [ %i1 + 0x14 ], %l6                      
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
 2010ebc:	80 a4 00 01 	cmp  %l0, %g1                                  
 2010ec0:	08 80 00 08 	bleu  2010ee0 <rtems_rfs_format+0x6f0>         <== ALWAYS TAKEN
 2010ec4:	b4 10 00 08 	mov  %o0, %i2                                  
  {                                                                   
    printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
 2010ec8:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2010ecc:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2010ed0:	40 00 44 2d 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010ed4:	90 12 20 30 	or  %o0, 0x30, %o0                             <== NOT EXECUTED
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
  if (rc > 0)                                                         
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
            rc, strerror (rc));                                       
    return false;                                                     
 2010ed8:	10 80 00 d9 	b  201123c <rtems_rfs_format+0xa4c>            <== NOT EXECUTED
 2010edc:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
  /*                                                                  
   * Be nice to strange sizes of disks. These are embedded systems after all
   * and nice numbers do not always work out. Let the last block pick up the
   * remainder of the blocks.                                         
   */                                                                 
  if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))           
 2010ee0:	84 04 00 1c 	add  %l0, %i4, %g2                             
 2010ee4:	80 a0 80 01 	cmp  %g2, %g1                                  
 2010ee8:	38 80 00 02 	bgu,a   2010ef0 <rtems_rfs_format+0x700>       <== ALWAYS TAKEN
 2010eec:	b8 20 40 10 	sub  %g1, %l0, %i4                             
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
 2010ef0:	80 8d e0 ff 	btst  0xff, %l7                                
 2010ef4:	22 80 00 09 	be,a   2010f18 <rtems_rfs_format+0x728>        <== ALWAYS TAKEN
 2010ef8:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           
    printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
 2010efc:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2010f00:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2010f04:	90 12 20 70 	or  %o0, 0x70, %o0                             <== NOT EXECUTED
 2010f08:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
 2010f0c:	40 00 44 1e 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010f10:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 2010f14:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 2010f18:	c0 27 bf 34 	clr  [ %fp + -204 ]                            
    printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n", 
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
 2010f1c:	80 8d e0 ff 	btst  0xff, %l7                                
 2010f20:	02 80 00 05 	be  2010f34 <rtems_rfs_format+0x744>           <== ALWAYS TAKEN
 2010f24:	c0 27 bf 38 	clr  [ %fp + -200 ]                            
    printf (", blocks");                                              
 2010f28:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2010f2c:	40 00 44 16 	call  2021f84 <printf>                         <== NOT EXECUTED
 2010f30:	90 12 20 a8 	or  %o0, 0xa8, %o0	! 20324a8 <_CPU_Trap_slot_template+0x470><== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the block bitmap using the new buffer.                      
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
 2010f34:	98 10 00 10 	mov  %l0, %o4                                  
 2010f38:	b6 07 bf 3c 	add  %fp, -196, %i3                            
 2010f3c:	92 07 bf 7c 	add  %fp, -132, %o1                            
 2010f40:	90 10 00 1b 	mov  %i3, %o0                                  
 2010f44:	94 07 bf 30 	add  %fp, -208, %o2                            
 2010f48:	40 00 24 28 	call  2019fe8 <rtems_rfs_bitmap_open>          
 2010f4c:	96 10 00 1c 	mov  %i4, %o3                                  
                              group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
 2010f50:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2010f54:	04 80 00 0a 	ble  2010f7c <rtems_rfs_format+0x78c>          <== ALWAYS TAKEN
 2010f58:	92 07 bf 30 	add  %fp, -208, %o1                            
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2010f5c:	7f ff fe 10 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 2010f60:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
 2010f64:	40 00 48 74 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010f68:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 2010f6c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2010f70:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2010f74:	10 80 00 17 	b  2010fd0 <rtems_rfs_format+0x7e0>            <== NOT EXECUTED
 2010f78:	90 12 20 b8 	or  %o0, 0xb8, %o0	! 20324b8 <_CPU_Trap_slot_template+0x480><== 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));
 2010f7c:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
 2010f80:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
 2010f84:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 2010f88:	40 00 43 81 	call  2021d8c <memset>                         
 2010f8c:	92 10 20 ff 	mov  0xff, %o1                                 
                                                                      
  /*                                                                  
   * Clear the bitmap.                                                
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
 2010f90:	40 00 23 6f 	call  2019d4c <rtems_rfs_bitmap_map_clear_all> 
 2010f94:	90 10 00 1b 	mov  %i3, %o0                                  
 2010f98:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
 2010f9c:	80 a4 20 00 	cmp  %l0, 0                                    
 2010fa0:	04 80 00 0f 	ble  2010fdc <rtems_rfs_format+0x7ec>          <== ALWAYS TAKEN
 2010fa4:	90 10 00 1b 	mov  %i3, %o0                                  
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
 2010fa8:	40 00 24 21 	call  201a02c <rtems_rfs_bitmap_close>         <== NOT EXECUTED
 2010fac:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2010fb0:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
 2010fb4:	7f ff fd fa 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 2010fb8:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
 2010fbc:	40 00 48 5e 	call  2023134 <strerror>                       <== NOT EXECUTED
 2010fc0:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
 2010fc4:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2010fc8:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2010fcc:	90 12 21 00 	or  %o0, 0x100, %o0	! 2032500 <_CPU_Trap_slot_template+0x4c8><== NOT EXECUTED
 2010fd0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2010fd4:	10 80 00 5e 	b  201114c <rtems_rfs_format+0x95c>            <== NOT EXECUTED
 2010fd8:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Forced allocation of the block bitmap.                           
   */                                                                 
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
 2010fdc:	40 00 22 d8 	call  2019b3c <rtems_rfs_bitmap_map_set>       
 2010fe0:	92 10 20 00 	clr  %o1                                       
                                                                      
  /*                                                                  
   * Forced allocation of the inode bitmap.                           
   */                                                                 
  rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
 2010fe4:	92 10 20 01 	mov  1, %o1                                    
 2010fe8:	40 00 22 d5 	call  2019b3c <rtems_rfs_bitmap_map_set>       
 2010fec:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  /*                                                                  
   * Determine the number of inodes blocks in the group.              
   */                                                                 
  blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
 2010ff0:	d0 07 bf a8 	ld  [ %fp + -88 ], %o0                         
 2010ff4:	d2 07 bf ac 	ld  [ %fp + -84 ], %o1                         
 2010ff8:	7f ff fd f3 	call  20107c4 <rtems_rfs_rup_quotient>         
 2010ffc:	a2 10 20 00 	clr  %l1                                       
 2011000:	10 80 00 05 	b  2011014 <rtems_rfs_format+0x824>            
 2011004:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
  /*                                                                  
   * 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);
 2011008:	92 04 60 02 	add  %l1, 2, %o1                               
 201100c:	40 00 22 cc 	call  2019b3c <rtems_rfs_bitmap_map_set>       
 2011010:	a2 04 60 01 	inc  %l1                                       
  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++)                                        
 2011014:	80 a4 40 10 	cmp  %l1, %l0                                  
 2011018:	06 bf ff fc 	bl  2011008 <rtems_rfs_format+0x818>           
 201101c:	90 10 00 1b 	mov  %i3, %o0                                  
    rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
                                                                      
  /*                                                                  
   * Close the block bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
 2011020:	40 00 24 03 	call  201a02c <rtems_rfs_bitmap_close>         
 2011024:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
 2011028:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 201102c:	24 80 00 0d 	ble,a   2011060 <rtems_rfs_format+0x870>       <== ALWAYS TAKEN
 2011030:	82 10 20 01 	mov  1, %g1                                    
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2011034:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
 2011038:	7f ff fd d9 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201103c:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
 2011040:	40 00 48 3d 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011044:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
 2011048:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201104c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2011050:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
 2011054:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2011058:	10 80 00 3d 	b  201114c <rtems_rfs_format+0x95c>            <== NOT EXECUTED
 201105c:	90 12 21 50 	or  %o0, 0x150, %o0	! 2032550 <_CPU_Trap_slot_template+0x518><== NOT EXECUTED
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
 2011060:	80 8d e0 ff 	btst  0xff, %l7                                
 2011064:	02 80 00 05 	be  2011078 <rtems_rfs_format+0x888>           <== ALWAYS TAKEN
 2011068:	c2 2f bf 30 	stb  %g1, [ %fp + -208 ]                       
    printf (", inodes");                                              
 201106c:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2011070:	40 00 43 c5 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011074:	90 12 21 98 	or  %o0, 0x198, %o0	! 2032598 <_CPU_Trap_slot_template+0x560><== NOT EXECUTED
                                                                      
  /*                                                                  
   * Open the inode bitmap using the old buffer. Should release any changes.
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
 2011078:	96 10 00 1c 	mov  %i4, %o3                                  
    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,                           
 201107c:	ae 07 bf 7c 	add  %fp, -132, %l7                            
    printf (", inodes");                                              
                                                                      
  /*                                                                  
   * Open the inode bitmap using the old buffer. Should release any changes.
   */                                                                 
  rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,       
 2011080:	b6 07 bf 30 	add  %fp, -208, %i3                            
 2011084:	90 07 bf 3c 	add  %fp, -196, %o0                            
 2011088:	92 10 00 17 	mov  %l7, %o1                                  
 201108c:	94 10 00 1b 	mov  %i3, %o2                                  
 2011090:	40 00 23 d6 	call  2019fe8 <rtems_rfs_bitmap_open>          
 2011094:	98 06 a0 02 	add  %i2, 2, %o4                               
                              group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
 2011098:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201109c:	04 80 00 09 	ble  20110c0 <rtems_rfs_format+0x8d0>          <== ALWAYS TAKEN
 20110a0:	92 10 00 1b 	mov  %i3, %o1                                  
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 20110a4:	7f ff fd be 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 20110a8:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
 20110ac:	40 00 48 22 	call  2023134 <strerror>                       <== NOT EXECUTED
 20110b0:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 20110b4:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 20110b8:	10 80 00 23 	b  2011144 <rtems_rfs_format+0x954>            <== NOT EXECUTED
 20110bc:	90 10 00 15 	mov  %l5, %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), 0x00, rtems_rfs_fs_block_size (fs));
 20110c0:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
 20110c4:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
 20110c8:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 20110cc:	40 00 43 30 	call  2021d8c <memset>                         
 20110d0:	92 10 20 00 	clr  %o1                                       
                                                                      
  /*                                                                  
   * Clear the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
 20110d4:	40 00 23 1e 	call  2019d4c <rtems_rfs_bitmap_map_clear_all> 
 20110d8:	90 07 bf 3c 	add  %fp, -196, %o0                            
 20110dc:	b8 10 00 08 	mov  %o0, %i4                                  
  if (rc > 0)                                                         
 20110e0:	80 a7 20 00 	cmp  %i4, 0                                    
 20110e4:	04 80 00 0c 	ble  2011114 <rtems_rfs_format+0x924>          <== ALWAYS TAKEN
 20110e8:	90 07 bf 3c 	add  %fp, -196, %o0                            
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
 20110ec:	40 00 23 d0 	call  201a02c <rtems_rfs_bitmap_close>         <== NOT EXECUTED
 20110f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 20110f4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 20110f8:	7f ff fd a9 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 20110fc:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \     
 2011100:	40 00 48 0d 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011104:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 2011108:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 201110c:	10 80 00 0e 	b  2011144 <rtems_rfs_format+0x954>            <== NOT EXECUTED
 2011110:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Close the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
 2011114:	40 00 23 c6 	call  201a02c <rtems_rfs_bitmap_close>         
 2011118:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
 201111c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2011120:	24 80 00 0f 	ble,a   201115c <rtems_rfs_format+0x96c>       <== ALWAYS TAKEN
 2011124:	82 10 20 01 	mov  1, %g1                                    
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 2011128:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201112c:	7f ff fd 9c 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 2011130:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close inode" \      
 2011134:	40 00 48 00 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011138:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201113c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
 2011140:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
 2011144:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2011148:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201114c:	40 00 43 8e 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011150:	01 00 00 00 	nop                                            <== NOT EXECUTED
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
  if (rc > 0)                                                         
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
            rc, strerror (rc));                                       
    return false;                                                     
 2011154:	10 80 00 3a 	b  201123c <rtems_rfs_format+0xa4c>            <== NOT EXECUTED
 2011158:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      <== NOT EXECUTED
    printf ("\nrtems-rfs: write-group: group %3d: close inode" \      
            " bitmap failed: %d: %s\n", group, rc, strerror (rc));    
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
 201115c:	c2 2f bf 30 	stb  %g1, [ %fp + -208 ]                       
                                                                      
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
 2011160:	80 8d a0 ff 	btst  0xff, %l6                                
 2011164:	12 80 00 27 	bne  2011200 <rtems_rfs_format+0xa10>          <== NEVER TAKEN
 2011168:	a2 10 20 00 	clr  %l1                                       
                                                                      
      rtems_rfs_buffer_mark_dirty (&handle);                          
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
 201116c:	90 07 bf 7c 	add  %fp, -132, %o0                            
 2011170:	7f ff fd 8b 	call  201079c <rtems_rfs_buffer_handle_close>  
 2011174:	92 07 bf 30 	add  %fp, -208, %o1                            
  if (rc > 0)                                                         
 2011178:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201117c:	04 80 00 30 	ble  201123c <rtems_rfs_format+0xa4c>          <== ALWAYS TAKEN
 2011180:	82 10 20 01 	mov  1, %g1                                    
 2011184:	30 80 00 27 	b,a   2011220 <rtems_rfs_format+0xa30>         <== NOT EXECUTED
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
 2011188:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
                                                                      
int                                                                   
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
 201118c:	b8 00 40 11 	add  %g1, %l1, %i4                             <== NOT EXECUTED
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
 2011190:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 2011194:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 2011198:	40 00 28 98 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201119c:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
                                            group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
                                            false);                   
      if (rc > 0)                                                     
 20111a0:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
 20111a4:	04 80 00 10 	ble  20111e4 <rtems_rfs_format+0x9f4>          <== NOT EXECUTED
 20111a8:	c4 07 bf 38 	ld  [ %fp + -200 ], %g2                        <== NOT EXECUTED
      {                                                               
        rtems_rfs_buffer_handle_close (fs, &handle);                  
 20111ac:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 20111b0:	7f ff fd 7b 	call  201079c <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 20111b4:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
        printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
 20111b8:	40 00 47 df 	call  2023134 <strerror>                       <== NOT EXECUTED
 20111bc:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 20111c0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 20111c4:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
 20111c8:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 20111cc:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 20111d0:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
 20111d4:	40 00 43 6c 	call  2021f84 <printf>                         <== NOT EXECUTED
 20111d8:	90 12 22 88 	or  %o0, 0x288, %o0                            <== NOT EXECUTED
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
  if (rc > 0)                                                         
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
            rc, strerror (rc));                                       
    return false;                                                     
 20111dc:	10 80 00 18 	b  201123c <rtems_rfs_format+0xa4c>            <== NOT EXECUTED
 20111e0:	82 10 20 00 	clr  %g1                                       <== 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));
 20111e4:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        <== NOT EXECUTED
 20111e8:	d0 00 a0 1c 	ld  [ %g2 + 0x1c ], %o0                        <== NOT EXECUTED
 20111ec:	92 10 20 ff 	mov  0xff, %o1                                 <== NOT EXECUTED
 20111f0:	40 00 42 e7 	call  2021d8c <memset>                         <== NOT EXECUTED
 20111f4:	a2 04 60 01 	inc  %l1                                       <== NOT EXECUTED
                                                                      
      rtems_rfs_buffer_mark_dirty (&handle);                          
 20111f8:	10 80 00 05 	b  201120c <rtems_rfs_format+0xa1c>            <== NOT EXECUTED
 20111fc:	ec 2f bf 30 	stb  %l6, [ %fp + -208 ]                       <== NOT EXECUTED
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
                                            group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
 2011200:	b4 06 a0 03 	add  %i2, 3, %i2                               <== 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));
                                                                      
      rtems_rfs_buffer_mark_dirty (&handle);                          
 2011204:	ac 10 20 01 	mov  1, %l6                                    <== NOT EXECUTED
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
                                            group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
 2011208:	f4 27 bf 24 	st  %i2, [ %fp + -220 ]                        <== NOT EXECUTED
  /*                                                                  
   * Initialise the inode tables if required to do so.                
   */                                                                 
  if (initialise_inodes)                                              
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
 201120c:	80 a4 40 10 	cmp  %l1, %l0                                  <== NOT EXECUTED
 2011210:	06 bf ff de 	bl  2011188 <rtems_rfs_format+0x998>           <== NOT EXECUTED
 2011214:	c2 07 bf 24 	ld  [ %fp + -220 ], %g1                        <== NOT EXECUTED
                                                                      
      rtems_rfs_buffer_mark_dirty (&handle);                          
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
 2011218:	10 bf ff d6 	b  2011170 <rtems_rfs_format+0x980>            <== NOT EXECUTED
 201121c:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
  if (rc > 0)                                                         
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
 2011220:	40 00 47 c5 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011224:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2011228:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201122c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011230:	40 00 43 55 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011234:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
 2011238:	82 10 20 00 	clr  %g1                                       <== 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,                           
 201123c:	80 88 60 ff 	btst  0xff, %g1                                
 2011240:	02 80 00 a9 	be  20114e4 <rtems_rfs_format+0xcf4>           <== NEVER TAKEN
 2011244:	ba 07 60 01 	inc  %i5                                       
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
 2011248:	10 80 00 0b 	b  2011274 <rtems_rfs_format+0xa84>            
 201124c:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
  if (rc > 0)                                                         
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
 2011250:	25 00 80 c9 	sethi  %hi(0x2032400), %l2                     
   */                                                                 
  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" \      
 2011254:	27 00 80 c9 	sethi  %hi(0x2032400), %l3                     
  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: inode bitmap" \     
 2011258:	29 00 80 c9 	sethi  %hi(0x2032400), %l4                     
  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",
 201125c:	2b 00 80 c9 	sethi  %hi(0x2032400), %l5                     
  }                                                                   
                                                                      
  rc = rtems_rfs_buffer_handle_close (fs, &handle);                   
  if (rc > 0)                                                         
  {                                                                   
    printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
 2011260:	a4 14 a2 d0 	or  %l2, 0x2d0, %l2                            
   */                                                                 
  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" \      
 2011264:	a6 14 e2 40 	or  %l3, 0x240, %l3                            
  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: inode bitmap" \     
 2011268:	a8 15 21 f0 	or  %l4, 0x1f0, %l4                            
  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",
 201126c:	aa 15 61 a8 	or  %l5, 0x1a8, %l5                            
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
  }                                                                   
                                                                      
  for (group = 0; group < fs.group_count; group++)                    
 2011270:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
 2011274:	80 a7 40 01 	cmp  %i5, %g1                                  
 2011278:	06 bf ff 0a 	bl  2010ea0 <rtems_rfs_format+0x6b0>           
 201127c:	ee 0e 60 15 	ldub  [ %i1 + 0x15 ], %l7                      
    if (!rtems_rfs_write_group (&fs, group,                           
                                config->initialise_inodes, config->verbose))
      return -1;                                                      
                                                                      
  if (config->verbose)                                                
 2011280:	80 8d e0 ff 	btst  0xff, %l7                                
 2011284:	02 80 00 04 	be  2011294 <rtems_rfs_format+0xaa4>           <== ALWAYS TAKEN
 2011288:	01 00 00 00 	nop                                            
    printf ("\n");                                                    
 201128c:	40 00 43 a8 	call  202212c <putchar>                        <== NOT EXECUTED
 2011290:	90 10 20 0a 	mov  0xa, %o0	! a <PROM_START+0xa>             <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_close (&fs);                                  
 2011294:	40 00 29 da 	call  201b9fc <rtems_rfs_buffer_close>         
 2011298:	90 07 bf 7c 	add  %fp, -132, %o0                            
  if (rc > 0)                                                         
 201129c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20112a0:	24 80 00 08 	ble,a   20112c0 <rtems_rfs_format+0xad0>       <== ALWAYS TAKEN
 20112a4:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    printf ("rtems-rfs: format: buffer close failed: %d: %s\n",       
 20112a8:	40 00 47 a3 	call  2023134 <strerror>                       <== NOT EXECUTED
 20112ac:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20112b0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20112b4:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 20112b8:	10 80 00 87 	b  20114d4 <rtems_rfs_format+0xce4>            <== NOT EXECUTED
 20112bc:	90 12 23 10 	or  %o0, 0x310, %o0	! 2032710 <_CPU_Trap_slot_template+0x6d8><== NOT EXECUTED
  int                    rc;                                          
                                                                      
  /*                                                                  
   * External API so returns -1.                                      
   */                                                                 
  rc = rtems_rfs_fs_open (name, NULL,                                 
 20112c0:	92 10 20 00 	clr  %o1                                       
 20112c4:	94 10 20 06 	mov  6, %o2                                    
 20112c8:	96 10 20 00 	clr  %o3                                       
 20112cc:	40 00 32 70 	call  201dc8c <rtems_rfs_fs_open>              
 20112d0:	98 07 bf 28 	add  %fp, -216, %o4                            
                          RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
                          0, &fs);                                    
  if (rc < 0)                                                         
 20112d4:	80 a2 20 00 	cmp  %o0, 0                                    
 20112d8:	36 80 00 0e 	bge,a   2011310 <rtems_rfs_format+0xb20>       <== ALWAYS TAKEN
 20112dc:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
  {                                                                   
    printf ("rtems-rfs: format: file system open failed: %d: %s\n",   
            errno, strerror (errno));                                 
 20112e0:	40 00 3d d0 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20112e4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 20112e8:	40 00 3d ce 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20112ec:	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",   
 20112f0:	40 00 47 91 	call  2023134 <strerror>                       <== NOT EXECUTED
 20112f4:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 20112f8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 20112fc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011300:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 2011304:	40 00 43 20 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011308:	90 12 23 40 	or  %o0, 0x340, %o0	! 2032740 <_CPU_Trap_slot_template+0x708><== NOT EXECUTED
 201130c:	30 80 00 77 	b,a   20114e8 <rtems_rfs_format+0xcf8>         <== NOT EXECUTED
            errno, strerror (errno));                                 
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);          
 2011310:	92 10 20 01 	mov  1, %o1                                    
 2011314:	40 00 02 38 	call  2011bf4 <rtems_rfs_inode_alloc>          
 2011318:	94 07 bf 2c 	add  %fp, -212, %o2                            
  if (rc > 0)                                                         
 201131c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2011320:	04 80 00 0a 	ble  2011348 <rtems_rfs_format+0xb58>          <== ALWAYS TAKEN
 2011324:	d2 07 bf 2c 	ld  [ %fp + -212 ], %o1                        
  {                                                                   
    printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",   
 2011328:	40 00 47 83 	call  2023134 <strerror>                       <== NOT EXECUTED
 201132c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2011330:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2011334:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011338:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 201133c:	40 00 43 12 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011340:	90 12 23 78 	or  %o0, 0x378, %o0	! 2032778 <_CPU_Trap_slot_template+0x740><== NOT EXECUTED
 2011344:	30 80 00 06 	b,a   201135c <rtems_rfs_format+0xb6c>         <== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  if (ino != RTEMS_RFS_ROOT_INO)                                      
 2011348:	80 a2 60 01 	cmp  %o1, 1                                    
 201134c:	02 80 00 08 	be  201136c <rtems_rfs_format+0xb7c>           <== ALWAYS TAKEN
 2011350:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     
  {                                                                   
    printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
 2011354:	40 00 43 0c 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011358:	90 12 23 b0 	or  %o0, 0x3b0, %o0	! 20327b0 <_CPU_Trap_slot_template+0x778><== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
 201135c:	40 00 34 47 	call  201e478 <rtems_rfs_fs_close>             <== NOT EXECUTED
 2011360:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
 2011364:	10 80 00 55 	b  20114b8 <rtems_rfs_format+0xcc8>            <== NOT EXECUTED
 2011368:	80 a7 60 00 	cmp  %i5, 0                                    <== 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);                  
 201136c:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
 2011370:	92 10 20 01 	mov  1, %o1                                    
 2011374:	94 07 bf 54 	add  %fp, -172, %o2                            
 2011378:	40 00 02 5b 	call  2011ce4 <rtems_rfs_inode_open>           
 201137c:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 2011380:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2011384:	24 80 00 0e 	ble,a   20113bc <rtems_rfs_format+0xbcc>       <== ALWAYS TAKEN
 2011388:	90 07 bf 54 	add  %fp, -172, %o0                            
  {                                                                   
    printf ("rtems-rfs: format: inode open failed: %d: %s\n",         
 201138c:	40 00 47 6a 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011390:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2011394:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2011398:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201139c:	11 00 80 c9 	sethi  %hi(0x2032400), %o0                     <== NOT EXECUTED
 20113a0:	40 00 42 f9 	call  2021f84 <printf>                         <== NOT EXECUTED
 20113a4:	90 12 23 e8 	or  %o0, 0x3e8, %o0	! 20327e8 <_CPU_Trap_slot_template+0x7b0><== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_group_bitmap_free (fs, true, ino);                      
 20113a8:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
 20113ac:	d4 07 bf 2c 	ld  [ %fp + -212 ], %o2                        <== NOT EXECUTED
 20113b0:	40 00 01 7c 	call  20119a0 <rtems_rfs_group_bitmap_free>    <== NOT EXECUTED
 20113b4:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 20113b8:	30 bf ff e9 	b,a   201135c <rtems_rfs_format+0xb6c>         <== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, 0,                         
 20113bc:	92 10 20 00 	clr  %o1                                       
 20113c0:	15 00 00 10 	sethi  %hi(0x4000), %o2                        
 20113c4:	96 10 20 00 	clr  %o3                                       
 20113c8:	94 12 a1 c9 	or  %o2, 0x1c9, %o2                            
 20113cc:	40 00 03 39 	call  20120b0 <rtems_rfs_inode_initialise>     
 20113d0:	98 10 20 00 	clr  %o4                                       
                                   (RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
                                    RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
                                   0, 0);                             
  if (rc > 0)                                                         
 20113d4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20113d8:	24 80 00 0a 	ble,a   2011400 <rtems_rfs_format+0xc10>       <== ALWAYS TAKEN
 20113dc:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
    printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",   
 20113e0:	40 00 47 55 	call  2023134 <strerror>                       <== NOT EXECUTED
 20113e4:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20113e8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 20113ec:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20113f0:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 20113f4:	40 00 42 e4 	call  2021f84 <printf>                         <== NOT EXECUTED
 20113f8:	90 12 20 18 	or  %o0, 0x18, %o0	! 2032818 <_CPU_Trap_slot_template+0x7e0><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);             
 20113fc:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
 2011400:	d8 07 bf 2c 	ld  [ %fp + -212 ], %o4                        
 2011404:	92 07 bf 54 	add  %fp, -172, %o1                            
 2011408:	15 00 80 c0 	sethi  %hi(0x2030000), %o2                     
 201140c:	96 10 20 01 	mov  1, %o3                                    
 2011410:	40 00 2a f7 	call  201bfec <rtems_rfs_dir_add_entry>        
 2011414:	94 12 a3 30 	or  %o2, 0x330, %o2                            
  if (rc > 0)                                                         
 2011418:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201141c:	24 80 00 0a 	ble,a   2011444 <rtems_rfs_format+0xc54>       <== ALWAYS TAKEN
 2011420:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
    printf ("rtems-rfs: format: directory add failed: %d: %s\n",      
 2011424:	40 00 47 44 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011428:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201142c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2011430:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011434:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011438:	40 00 42 d3 	call  2021f84 <printf>                         <== NOT EXECUTED
 201143c:	90 12 20 50 	or  %o0, 0x50, %o0	! 2032850 <_CPU_Trap_slot_template+0x818><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 2011440:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
 2011444:	40 00 02 9a 	call  2011eac <rtems_rfs_inode_close>          
 2011448:	92 07 bf 54 	add  %fp, -172, %o1                            
  if (rc > 0)                                                         
 201144c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2011450:	04 80 00 09 	ble  2011474 <rtems_rfs_format+0xc84>          <== ALWAYS TAKEN
 2011454:	01 00 00 00 	nop                                            
    printf ("rtems-rfs: format: inode close failed: %d: %s\n",        
 2011458:	40 00 47 37 	call  2023134 <strerror>                       <== NOT EXECUTED
 201145c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2011460:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2011464:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011468:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 201146c:	40 00 42 c6 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011470:	90 12 20 88 	or  %o0, 0x88, %o0	! 2032888 <_CPU_Trap_slot_template+0x850><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_fs_close (fs);                                       
 2011474:	40 00 34 01 	call  201e478 <rtems_rfs_fs_close>             
 2011478:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
  if (rc < 0)                                                         
 201147c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2011480:	16 80 00 0e 	bge  20114b8 <rtems_rfs_format+0xcc8>          <== ALWAYS TAKEN
 2011484:	80 a7 60 00 	cmp  %i5, 0                                    
    printf ("rtems-rfs: format: file system close failed: %d: %s\n",  
            errno, strerror (errno));                                 
 2011488:	40 00 3d 66 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201148c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2011490:	40 00 3d 64 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2011494:	f8 02 00 00 	ld  [ %o0 ], %i4                               <== 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",  
 2011498:	40 00 47 27 	call  2023134 <strerror>                       <== NOT EXECUTED
 201149c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 20114a0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 20114a4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20114a8:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 20114ac:	40 00 42 b6 	call  2021f84 <printf>                         <== NOT EXECUTED
 20114b0:	90 12 20 b8 	or  %o0, 0xb8, %o0	! 20328b8 <_CPU_Trap_slot_template+0x880><== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
 20114b4:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
 20114b8:	24 80 00 0c 	ble,a   20114e8 <rtems_rfs_format+0xcf8>       <== ALWAYS TAKEN
 20114bc:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",   
 20114c0:	40 00 47 1d 	call  2023134 <strerror>                       <== NOT EXECUTED
 20114c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20114c8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20114cc:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 20114d0:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 20328f0 <_CPU_Trap_slot_template+0x8b8><== NOT EXECUTED
 20114d4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 20114d8:	40 00 42 ab 	call  2021f84 <printf>                         <== NOT EXECUTED
 20114dc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20114e0:	30 80 00 02 	b,a   20114e8 <rtems_rfs_format+0xcf8>         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * Check the configuration data.                                    
   */                                                                 
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
 20114e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20114e8:	81 c7 e0 08 	ret                                            
 20114ec:	81 e8 00 00 	restore                                        
                            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;                      
 20114f0:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        
   * Check the configuration data.                                    
   */                                                                 
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
                                                                      
  if (config->verbose)                                                
 20114f4:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
 20114f8:	80 a0 60 00 	cmp  %g1, 0                                    
 20114fc:	02 bf fd d0 	be  2010c3c <rtems_rfs_format+0x44c>           <== ALWAYS TAKEN
 2011500:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        
 2011504:	30 bf fd 6f 	b,a   2010ac0 <rtems_rfs_format+0x2d0>         <== NOT EXECUTED
                                                                      

0201e478 <rtems_rfs_fs_close>: int rtems_rfs_fs_close (rtems_rfs_file_system* fs) {
 201e478:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
 201e47c:	90 10 20 00 	clr  %o0                                       
 201e480:	7f ff d4 a2 	call  2013708 <rtems_rfs_trace>                
 201e484:	92 10 20 02 	mov  2, %o1                                    
 201e488:	80 8a 20 ff 	btst  0xff, %o0                                
 201e48c:	22 80 00 06 	be,a   201e4a4 <rtems_rfs_fs_close+0x2c>       <== ALWAYS TAKEN
 201e490:	b8 10 20 00 	clr  %i4                                       
    printf ("rtems-rfs: close\n");                                    
 201e494:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e498:	40 00 0f 53 	call  20221e4 <puts>                           <== NOT EXECUTED
 201e49c:	90 12 20 c8 	or  %o0, 0xc8, %o0	! 20348c8 <CSWTCH.2+0x13e8> <== NOT EXECUTED
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_fs_close (rtems_rfs_file_system* fs)                        
{                                                                     
 201e4a0:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
 201e4a4:	10 80 00 07 	b  201e4c0 <rtems_rfs_fs_close+0x48>           
 201e4a8:	ba 10 20 00 	clr  %i5                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
 201e4ac:	90 10 00 18 	mov  %i0, %o0                                  
 201e4b0:	92 02 40 1c 	add  %o1, %i4, %o1                             
 201e4b4:	7f ff cc 93 	call  2011700 <rtems_rfs_group_close>          
 201e4b8:	ba 07 60 01 	inc  %i5                                       
 201e4bc:	b8 07 20 50 	add  %i4, 0x50, %i4                            
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
 201e4c0:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
 201e4c4:	80 a7 40 01 	cmp  %i5, %g1                                  
 201e4c8:	26 bf ff f9 	bl,a   201e4ac <rtems_rfs_fs_close+0x34>       
 201e4cc:	d2 06 20 20 	ld  [ %i0 + 0x20 ], %o1                        
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
                                                                      
  rtems_rfs_buffer_close (fs);                                        
 201e4d0:	7f ff f5 4b 	call  201b9fc <rtems_rfs_buffer_close>         
 201e4d4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  free (fs);                                                          
 201e4d8:	90 10 00 18 	mov  %i0, %o0                                  
 201e4dc:	7f ff a6 c2 	call  2007fe4 <free>                           
 201e4e0:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
 201e4e4:	81 c7 e0 08 	ret                                            
 201e4e8:	81 e8 00 00 	restore                                        
                                                                      

0201dc8c <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) {
 201dc8c:	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))                         
 201dc90:	90 10 20 00 	clr  %o0                                       
 201dc94:	7f ff d6 9d 	call  2013708 <rtems_rfs_trace>                
 201dc98:	92 10 20 01 	mov  1, %o1                                    
 201dc9c:	80 8a 20 ff 	btst  0xff, %o0                                
 201dca0:	02 80 00 05 	be  201dcb4 <rtems_rfs_fs_open+0x28>           <== ALWAYS TAKEN
 201dca4:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     
    printf ("rtems-rfs: open: %s\n", name);                           
 201dca8:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 201dcac:	40 00 10 b6 	call  2021f84 <printf>                         <== NOT EXECUTED
 201dcb0:	90 12 21 88 	or  %o0, 0x188, %o0                            <== NOT EXECUTED
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
 201dcb4:	7f ff aa 5d 	call  2008628 <malloc>                         
 201dcb8:	90 10 20 84 	mov  0x84, %o0                                 
  if (!*fs)                                                           
 201dcbc:	80 a2 20 00 	cmp  %o0, 0                                    
 201dcc0:	12 80 00 0f 	bne  201dcfc <rtems_rfs_fs_open+0x70>          <== ALWAYS TAKEN
 201dcc4:	d0 27 00 00 	st  %o0, [ %i4 ]                               
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201dcc8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201dccc:	7f ff d6 8f 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201dcd0:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201dcd4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201dcd8:	02 80 00 05 	be  201dcec <rtems_rfs_fs_open+0x60>           <== NOT EXECUTED
 201dcdc:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: no memory for file system data\n");   
 201dce0:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201dce4:	40 00 11 40 	call  20221e4 <puts>                           <== NOT EXECUTED
 201dce8:	90 12 21 a0 	or  %o0, 0x1a0, %o0	! 20345a0 <CSWTCH.2+0x10c0><== NOT EXECUTED
    errno = ENOMEM;                                                   
 201dcec:	40 00 0b 4d 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201dcf0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201dcf4:	10 80 01 c5 	b  201e408 <rtems_rfs_fs_open+0x77c>           <== NOT EXECUTED
 201dcf8:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
 201dcfc:	92 10 20 00 	clr  %o1                                       
 201dd00:	40 00 10 23 	call  2021d8c <memset>                         
 201dd04:	94 10 20 84 	mov  0x84, %o2                                 
                                                                      
  (*fs)->user = user;                                                 
 201dd08:	c2 07 00 00 	ld  [ %i4 ], %g1                               
#endif                                                                
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
 201dd0c:	90 10 00 18 	mov  %i0, %o0                                  
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
                                                                      
  (*fs)->user = user;                                                 
 201dd10:	f2 20 60 80 	st  %i1, [ %g1 + 0x80 ]                        
  rtems_chain_initialize_empty (&(*fs)->buffers);                     
 201dd14:	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;                                              
 201dd18:	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 );                        
 201dd1c:	84 00 60 44 	add  %g1, 0x44, %g2                            
 201dd20:	86 00 60 48 	add  %g1, 0x48, %g3                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201dd24:	c4 20 60 4c 	st  %g2, [ %g1 + 0x4c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 201dd28:	c6 20 60 44 	st  %g3, [ %g1 + 0x44 ]                        
  rtems_chain_initialize_empty (&(*fs)->release);                     
 201dd2c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
 201dd30:	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 );                        
 201dd34:	84 00 60 54 	add  %g1, 0x54, %g2                            
 201dd38:	86 00 60 58 	add  %g1, 0x58, %g3                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201dd3c:	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;                                                  
 201dd40:	c6 20 60 54 	st  %g3, [ %g1 + 0x54 ]                        
  rtems_chain_initialize_empty (&(*fs)->release_modified);            
 201dd44:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
 201dd48:	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 );                        
 201dd4c:	84 00 60 64 	add  %g1, 0x64, %g2                            
 201dd50:	86 00 60 68 	add  %g1, 0x68, %g3                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201dd54:	c4 20 60 6c 	st  %g2, [ %g1 + 0x6c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 201dd58:	c6 20 60 64 	st  %g3, [ %g1 + 0x64 ]                        
  rtems_chain_initialize_empty (&(*fs)->file_shares);                 
 201dd5c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
 201dd60:	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 );                        
 201dd64:	84 00 60 74 	add  %g1, 0x74, %g2                            
 201dd68:	86 00 60 78 	add  %g1, 0x78, %g3                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
 201dd6c:	c4 20 60 7c 	st  %g2, [ %g1 + 0x7c ]                        
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
 201dd70:	c6 20 60 74 	st  %g3, [ %g1 + 0x74 ]                        
                                                                      
  (*fs)->max_held_buffers = max_held_buffers;                         
 201dd74:	d2 07 00 00 	ld  [ %i4 ], %o1                               
 201dd78:	f6 22 60 40 	st  %i3, [ %o1 + 0x40 ]                        
  (*fs)->buffers_count = 0;                                           
 201dd7c:	c0 22 60 50 	clr  [ %o1 + 0x50 ]                            
  (*fs)->release_count = 0;                                           
 201dd80:	c0 22 60 60 	clr  [ %o1 + 0x60 ]                            
  (*fs)->release_modified_count = 0;                                  
 201dd84:	c0 22 60 70 	clr  [ %o1 + 0x70 ]                            
#endif                                                                
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
 201dd88:	7f ff f6 42 	call  201b690 <rtems_rfs_buffer_open>          
 201dd8c:	f4 22 40 00 	st  %i2, [ %o1 ]                               
  if (rc > 0)                                                         
 201dd90:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201dd94:	04 80 00 16 	ble  201ddec <rtems_rfs_fs_open+0x160>         <== ALWAYS TAKEN
 201dd98:	f6 07 00 00 	ld  [ %i4 ], %i3                               
  {                                                                   
    free (*fs);                                                       
 201dd9c:	7f ff a8 92 	call  2007fe4 <free>                           <== NOT EXECUTED
 201dda0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201dda4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201dda8:	7f ff d6 58 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201ddac:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201ddb0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201ddb4:	02 80 00 09 	be  201ddd8 <rtems_rfs_fs_open+0x14c>          <== NOT EXECUTED
 201ddb8:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: buffer open failed: %d: %s\n",        
 201ddbc:	40 00 14 de 	call  2023134 <strerror>                       <== NOT EXECUTED
 201ddc0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ddc4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201ddc8:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201ddcc:	90 12 21 d0 	or  %o0, 0x1d0, %o0	! 20345d0 <CSWTCH.2+0x10f0><== NOT EXECUTED
 201ddd0:	40 00 10 6d 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ddd4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
              rc, strerror (rc));                                     
    errno = rc;                                                       
 201ddd8:	40 00 0b 12 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201dddc:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201dde0:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
    return -1;                                                        
 201dde4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201dde8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201ddec:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            
  handle->bnum  = 0;                                                  
 201ddf0:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
  handle->buffer = NULL;                                              
 201ddf4:	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);        
 201ddf8:	90 10 00 1b 	mov  %i3, %o0                                  
 201ddfc:	92 07 bf cc 	add  %fp, -52, %o1                             
 201de00:	94 10 20 00 	clr  %o2                                       
 201de04:	7f ff f5 7d 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 201de08:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 201de0c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201de10:	04 80 00 0d 	ble  201de44 <rtems_rfs_fs_open+0x1b8>         <== ALWAYS TAKEN
 201de14:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201de18:	7f ff d6 3c 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201de1c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201de20:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201de24:	22 80 01 2d 	be,a   201e2d8 <rtems_rfs_fs_open+0x64c>       <== NOT EXECUTED
 201de28:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: request failed%d: %s\n",   
 201de2c:	40 00 14 c2 	call  2023134 <strerror>                       <== NOT EXECUTED
 201de30:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201de34:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201de38:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201de3c:	10 80 00 de 	b  201e1b4 <rtems_rfs_fs_open+0x528>           <== NOT EXECUTED
 201de40:	90 12 22 00 	or  %o0, 0x200, %o0	! 2034600 <CSWTCH.2+0x1120><== NOT EXECUTED
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  sb = rtems_rfs_buffer_data (&handle);                               
 201de44:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1                         
 201de48:	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)      
 201de4c:	c2 0f 60 01 	ldub  [ %i5 + 1 ], %g1                         
 201de50:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             
 201de54:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201de58:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201de5c:	84 10 80 01 	or  %g2, %g1, %g2                              
 201de60:	c2 0f 60 03 	ldub  [ %i5 + 3 ], %g1                         
 201de64:	84 10 80 01 	or  %g2, %g1, %g2                              
 201de68:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
 201de6c:	83 28 60 08 	sll  %g1, 8, %g1                               
 201de70:	84 10 80 01 	or  %g2, %g1, %g2                              
 201de74:	03 0a 02 48 	sethi  %hi(0x28092000), %g1                    
 201de78:	82 10 60 01 	or  %g1, 1, %g1	! 28092001 <RAM_END+0x25c92001>
 201de7c:	80 a0 80 01 	cmp  %g2, %g1                                  
 201de80:	22 80 00 0b 	be,a   201deac <rtems_rfs_fs_open+0x220>       <== ALWAYS TAKEN
 201de84:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201de88:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201de8c:	7f ff d6 1f 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201de90:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201de94:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201de98:	22 80 00 57 	be,a   201dff4 <rtems_rfs_fs_open+0x368>       <== NOT EXECUTED
 201de9c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
 201dea0:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201dea4:	10 80 00 2f 	b  201df60 <rtems_rfs_fs_open+0x2d4>           <== NOT EXECUTED
 201dea8:	90 12 22 38 	or  %o0, 0x238, %o0	! 2034638 <CSWTCH.2+0x1158><== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
 201deac:	d6 0f 60 0c 	ldub  [ %i5 + 0xc ], %o3                       
 201deb0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201deb4:	97 2a e0 18 	sll  %o3, 0x18, %o3                            
 201deb8:	96 12 c0 01 	or  %o3, %g1, %o3                              
 201debc:	c2 0f 60 0f 	ldub  [ %i5 + 0xf ], %g1                       
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;                                         
 201dec0:	94 10 20 00 	clr  %o2                                       
      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
 201dec4:	96 12 c0 01 	or  %o3, %g1, %o3                              
 201dec8:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
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;                                         
 201decc:	90 10 20 00 	clr  %o0                                       
      printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->blocks     = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);              
 201ded0:	83 28 60 08 	sll  %g1, 8, %g1                               
 201ded4:	96 12 c0 01 	or  %o3, %g1, %o3                              
 201ded8:	d6 26 e0 04 	st  %o3, [ %i3 + 4 ]                           
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
 201dedc:	c2 0f 60 09 	ldub  [ %i5 + 9 ], %g1                         
 201dee0:	f4 0f 60 08 	ldub  [ %i5 + 8 ], %i2                         
 201dee4:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201dee8:	b5 2e a0 18 	sll  %i2, 0x18, %i2                            
 201deec:	b4 16 80 01 	or  %i2, %g1, %i2                              
 201def0:	c2 0f 60 0b 	ldub  [ %i5 + 0xb ], %g1                       
 201def4:	b4 16 80 01 	or  %i2, %g1, %i2                              
 201def8:	c2 0f 60 0a 	ldub  [ %i5 + 0xa ], %g1                       
 201defc:	83 28 60 08 	sll  %g1, 8, %g1                               
 201df00:	b4 16 80 01 	or  %i2, %g1, %i2                              
 201df04:	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;                                         
 201df08:	40 00 41 4c 	call  202e438 <__muldi3>                       
 201df0c:	92 10 00 1a 	mov  %i2, %o1                                  
 201df10:	b2 10 00 08 	mov  %o0, %i1                                  
 201df14:	b0 10 00 09 	mov  %o1, %i0                                  
  }                                                                   
                                                                      
  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))           
 201df18:	7f ff ff 53 	call  201dc64 <rtems_rfs_fs_media_size>        
 201df1c:	90 10 00 1b 	mov  %i3, %o0                                  
 201df20:	80 a6 40 08 	cmp  %i1, %o0                                  
 201df24:	38 80 00 08 	bgu,a   201df44 <rtems_rfs_fs_open+0x2b8>      <== NEVER TAKEN
 201df28:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201df2c:	32 80 00 11 	bne,a   201df70 <rtems_rfs_fs_open+0x2e4>      <== NEVER TAKEN
 201df30:	c4 0f 60 24 	ldub  [ %i5 + 0x24 ], %g2                      <== NOT EXECUTED
 201df34:	80 a6 00 09 	cmp  %i0, %o1                                  
 201df38:	28 80 00 0e 	bleu,a   201df70 <rtems_rfs_fs_open+0x2e4>     <== ALWAYS TAKEN
 201df3c:	c4 0f 60 24 	ldub  [ %i5 + 0x24 ], %g2                      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201df40:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201df44:	7f ff d5 f1 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201df48:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201df4c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201df50:	22 80 00 29 	be,a   201dff4 <rtems_rfs_fs_open+0x368>       <== NOT EXECUTED
 201df54:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
 201df58:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201df5c:	90 12 22 78 	or  %o0, 0x278, %o0	! 2034678 <CSWTCH.2+0x1198><== NOT EXECUTED
 201df60:	40 00 10 a1 	call  20221e4 <puts>                           <== NOT EXECUTED
 201df64:	01 00 00 00 	nop                                            <== 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",
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 201df68:	10 80 00 23 	b  201dff4 <rtems_rfs_fs_open+0x368>           <== NOT EXECUTED
 201df6c:	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;                                                       
  }                                                                   
                                                                      
  if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
 201df70:	c2 0f 60 25 	ldub  [ %i5 + 0x25 ], %g1                      
 201df74:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201df78:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201df7c:	82 10 80 01 	or  %g2, %g1, %g1                              
 201df80:	c4 0f 60 27 	ldub  [ %i5 + 0x27 ], %g2                      
 201df84:	82 10 40 02 	or  %g1, %g2, %g1                              
 201df88:	c4 0f 60 26 	ldub  [ %i5 + 0x26 ], %g2                      
 201df8c:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201df90:	82 10 40 02 	or  %g1, %g2, %g1                              
 201df94:	80 a0 60 38 	cmp  %g1, 0x38                                 
 201df98:	22 80 00 1b 	be,a   201e004 <rtems_rfs_fs_open+0x378>       <== ALWAYS TAKEN
 201df9c:	c4 0f 60 10 	ldub  [ %i5 + 0x10 ], %g2                      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201dfa0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201dfa4:	7f ff d5 d9 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201dfa8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201dfac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201dfb0:	22 80 00 11 	be,a   201dff4 <rtems_rfs_fs_open+0x368>       <== NOT EXECUTED
 201dfb4:	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);
 201dfb8:	c2 0f 60 05 	ldub  [ %i5 + 5 ], %g1                         <== NOT EXECUTED
 201dfbc:	d2 0f 60 04 	ldub  [ %i5 + 4 ], %o1                         <== NOT EXECUTED
 201dfc0:	83 28 60 10 	sll  %g1, 0x10, %g1                            <== NOT EXECUTED
 201dfc4:	93 2a 60 18 	sll  %o1, 0x18, %o1                            <== NOT EXECUTED
 201dfc8:	92 12 40 01 	or  %o1, %g1, %o1                              <== NOT EXECUTED
 201dfcc:	c2 0f 60 07 	ldub  [ %i5 + 7 ], %g1                         <== 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",
 201dfd0:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
 201dfd4:	92 12 40 01 	or  %o1, %g1, %o1                              <== NOT EXECUTED
 201dfd8:	c2 0f 60 06 	ldub  [ %i5 + 6 ], %g1                         <== 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",
 201dfdc:	90 12 22 b8 	or  %o0, 0x2b8, %o0                            <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
 201dfe0:	83 28 60 08 	sll  %g1, 8, %g1                               <== 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",
 201dfe4:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201dfe8:	40 00 0f e7 	call  2021f84 <printf>                         <== NOT EXECUTED
 201dfec:	92 12 40 01 	or  %o1, %g1, %o1                              <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 201dff0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
 201dff4:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
 201dff8:	7f ff ff 08 	call  201dc18 <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201dffc:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
 201e000:	30 80 00 b8 	b,a   201e2e0 <rtems_rfs_fs_open+0x654>        <== NOT EXECUTED
    return EIO;                                                       
  }                                                                   
                                                                      
  fs->bad_blocks      = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);     
 201e004:	c2 0f 60 11 	ldub  [ %i5 + 0x11 ], %g1                      
 201e008:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201e00c:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201e010:	82 10 80 01 	or  %g2, %g1, %g1                              
 201e014:	c4 0f 60 13 	ldub  [ %i5 + 0x13 ], %g2                      
  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 =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
 201e018:	91 36 a0 02 	srl  %i2, 2, %o0                               
              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);     
 201e01c:	82 10 40 02 	or  %g1, %g2, %g1                              
 201e020:	c4 0f 60 12 	ldub  [ %i5 + 0x12 ], %g2                      
    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;
 201e024:	92 10 00 08 	mov  %o0, %o1                                  
              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);     
 201e028:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201e02c:	82 10 40 02 	or  %g1, %g2, %g1                              
 201e030:	c2 26 e0 18 	st  %g1, [ %i3 + 0x18 ]                        
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
 201e034:	c4 0f 60 14 	ldub  [ %i5 + 0x14 ], %g2                      
 201e038:	c2 0f 60 15 	ldub  [ %i5 + 0x15 ], %g1                      
 201e03c:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201e040:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201e044:	82 10 80 01 	or  %g2, %g1, %g1                              
 201e048:	c4 0f 60 17 	ldub  [ %i5 + 0x17 ], %g2                      
 201e04c:	82 10 40 02 	or  %g1, %g2, %g1                              
 201e050:	c4 0f 60 16 	ldub  [ %i5 + 0x16 ], %g2                      
 201e054:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201e058:	82 10 40 02 	or  %g1, %g2, %g1                              
 201e05c:	c2 26 e0 1c 	st  %g1, [ %i3 + 0x1c ]                        
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
 201e060:	c2 0f 60 19 	ldub  [ %i5 + 0x19 ], %g1                      
 201e064:	f0 0f 60 18 	ldub  [ %i5 + 0x18 ], %i0                      
 201e068:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201e06c:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
 201e070:	b0 16 00 01 	or  %i0, %g1, %i0                              
 201e074:	c2 0f 60 1b 	ldub  [ %i5 + 0x1b ], %g1                      
 201e078:	b0 16 00 01 	or  %i0, %g1, %i0                              
 201e07c:	c2 0f 60 1a 	ldub  [ %i5 + 0x1a ], %g1                      
 201e080:	83 28 60 08 	sll  %g1, 8, %g1                               
 201e084:	b0 16 00 01 	or  %i0, %g1, %i0                              
 201e088:	f0 26 e0 24 	st  %i0, [ %i3 + 0x24 ]                        
  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);   
 201e08c:	c2 0f 60 1d 	ldub  [ %i5 + 0x1d ], %g1                      
 201e090:	f2 0f 60 1c 	ldub  [ %i5 + 0x1c ], %i1                      
 201e094:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201e098:	b3 2e 60 18 	sll  %i1, 0x18, %i1                            
 201e09c:	b2 16 40 01 	or  %i1, %g1, %i1                              
 201e0a0:	c2 0f 60 1f 	ldub  [ %i5 + 0x1f ], %g1                      
 201e0a4:	b2 16 40 01 	or  %i1, %g1, %i1                              
 201e0a8:	c2 0f 60 1e 	ldub  [ %i5 + 0x1e ], %g1                      
 201e0ac:	83 28 60 08 	sll  %g1, 8, %g1                               
 201e0b0:	b2 16 40 01 	or  %i1, %g1, %i1                              
 201e0b4:	f2 26 e0 28 	st  %i1, [ %i3 + 0x28 ]                        
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
 201e0b8:	c2 0f 60 21 	ldub  [ %i5 + 0x21 ], %g1                      
 201e0bc:	c4 0f 60 20 	ldub  [ %i5 + 0x20 ], %g2                      
 201e0c0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201e0c4:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201e0c8:	84 10 80 01 	or  %g2, %g1, %g2                              
 201e0cc:	c2 0f 60 23 	ldub  [ %i5 + 0x23 ], %g1                      
 201e0d0:	84 10 80 01 	or  %g2, %g1, %g2                              
 201e0d4:	c2 0f 60 22 	ldub  [ %i5 + 0x22 ], %g1                      
                                                                      
  fs->blocks_per_block =                                              
 201e0d8:	d0 26 e0 34 	st  %o0, [ %i3 + 0x34 ]                        
                                                                      
  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);   
 201e0dc:	83 28 60 08 	sll  %g1, 8, %g1                               
 201e0e0:	ba 10 80 01 	or  %g2, %g1, %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;                    
 201e0e4:	85 2a 20 02 	sll  %o0, 2, %g2                               
 201e0e8:	84 00 80 08 	add  %g2, %o0, %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);   
 201e0ec:	fa 26 e0 2c 	st  %i5, [ %i3 + 0x2c ]                        
    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;
 201e0f0:	7f ff 91 29 	call  2002594 <.umul>                          
 201e0f4:	c4 26 e0 38 	st  %g2, [ %i3 + 0x38 ]                        
 201e0f8:	83 2a 20 02 	sll  %o0, 2, %g1                               
 201e0fc:	90 00 40 08 	add  %g1, %o0, %o0                             
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
 201e100:	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 =                                       
 201e104:	d0 26 e0 3c 	st  %o0, [ %i3 + 0x3c ]                        
    fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
 201e108:	7f ff 91 23 	call  2002594 <.umul>                          
 201e10c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
 201e110:	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;                    
 201e114:	d0 26 e0 14 	st  %o0, [ %i3 + 0x14 ]                        
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
 201e118:	7f ff 91 59 	call  200267c <.udiv>                          
 201e11c:	90 10 00 1a 	mov  %i2, %o0                                  
 201e120:	d0 26 e0 30 	st  %o0, [ %i3 + 0x30 ]                        
                                                                      
  if (fs->group_blocks >                                              
      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))     
 201e124:	b5 2e a0 03 	sll  %i2, 3, %i2                               
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 201e128:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
                                                                      
  if (fs->group_blocks >                                              
 201e12c:	80 a6 40 1a 	cmp  %i1, %i2                                  
 201e130:	08 80 00 0c 	bleu  201e160 <rtems_rfs_fs_open+0x4d4>        <== ALWAYS TAKEN
 201e134:	92 07 bf cc 	add  %fp, -52, %o1                             
      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))     
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 201e138:	7f ff fe b8 	call  201dc18 <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201e13c:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201e140:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e144:	7f ff d5 71 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e148:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e14c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e150:	02 80 00 64 	be  201e2e0 <rtems_rfs_fs_open+0x654>          <== NOT EXECUTED
 201e154:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
 201e158:	10 80 00 2e 	b  201e210 <rtems_rfs_fs_open+0x584>           <== NOT EXECUTED
 201e15c:	90 12 23 00 	or  %o0, 0x300, %o0	! 2034700 <CSWTCH.2+0x1220><== NOT EXECUTED
    return EIO;                                                       
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &handle);                        
 201e160:	7f ff fe ae 	call  201dc18 <rtems_rfs_buffer_handle_close>  
 201e164:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Change the block size to the value in the superblock.            
   */                                                                 
  rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
 201e168:	d2 06 e0 08 	ld  [ %i3 + 8 ], %o1                           
 201e16c:	7f ff f5 e9 	call  201b910 <rtems_rfs_buffer_setblksize>    
 201e170:	90 10 00 1b 	mov  %i3, %o0                                  
  if (rc > 0)                                                         
 201e174:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e178:	04 80 00 13 	ble  201e1c4 <rtems_rfs_fs_open+0x538>         <== ALWAYS TAKEN
 201e17c:	92 07 bf cc 	add  %fp, -52, %o1                             
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 201e180:	7f ff fe a6 	call  201dc18 <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201e184:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201e188:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e18c:	7f ff d5 5f 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e190:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e194:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e198:	22 80 00 50 	be,a   201e2d8 <rtems_rfs_fs_open+0x64c>       <== NOT EXECUTED
 201e19c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
 201e1a0:	40 00 13 e5 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e1a4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e1a8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e1ac:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201e1b0:	90 12 23 48 	or  %o0, 0x348, %o0	! 2034748 <CSWTCH.2+0x1268><== NOT EXECUTED
 201e1b4:	40 00 0f 74 	call  2021f84 <printf>                         <== NOT EXECUTED
 201e1b8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
 201e1bc:	10 80 00 47 	b  201e2d8 <rtems_rfs_fs_open+0x64c>           <== NOT EXECUTED
 201e1c0:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));    
 201e1c4:	d0 06 e0 24 	ld  [ %i3 + 0x24 ], %o0                        
 201e1c8:	7f ff a6 87 	call  2007be4 <calloc>                         
 201e1cc:	92 10 20 50 	mov  0x50, %o1                                 
 201e1d0:	d0 26 e0 20 	st  %o0, [ %i3 + 0x20 ]                        
                                                                      
  if (!fs->groups)                                                    
 201e1d4:	b2 10 20 00 	clr  %i1                                       
 201e1d8:	80 a2 20 00 	cmp  %o0, 0                                    
 201e1dc:	12 80 00 39 	bne  201e2c0 <rtems_rfs_fs_open+0x634>         <== ALWAYS TAKEN
 201e1e0:	b4 10 20 00 	clr  %i2                                       
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
 201e1e4:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
 201e1e8:	7f ff fe 8c 	call  201dc18 <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201e1ec:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201e1f0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e1f4:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e1f8:	7f ff d5 44 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e1fc:	ba 10 20 0c 	mov  0xc, %i5                                  <== NOT EXECUTED
 201e200:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e204:	02 80 00 37 	be  201e2e0 <rtems_rfs_fs_open+0x654>          <== NOT EXECUTED
 201e208:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: no memory for group table\n");
 201e20c:	90 12 23 90 	or  %o0, 0x390, %o0	! 2034790 <CSWTCH.2+0x12b0><== NOT EXECUTED
 201e210:	40 00 0f f5 	call  20221e4 <puts>                           <== NOT EXECUTED
 201e214:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201e218:	30 80 00 32 	b,a   201e2e0 <rtems_rfs_fs_open+0x654>        <== NOT EXECUTED
   * close everything.                                                
   */                                                                 
  for (group = 0; group < fs->group_count; group++)                   
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
                               rtems_rfs_fs_block (fs, group, 0),     
 201e21c:	90 10 00 1a 	mov  %i2, %o0                                  
 201e220:	7f ff 90 dd 	call  2002594 <.umul>                          
 201e224:	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,                                    
 201e228:	d8 06 e0 20 	ld  [ %i3 + 0x20 ], %o4                        
 201e22c:	d6 06 e0 2c 	ld  [ %i3 + 0x2c ], %o3                        
                               rtems_rfs_fs_block (fs, group, 0),     
 201e230:	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,                                    
 201e234:	94 10 00 1d 	mov  %i5, %o2                                  
 201e238:	98 03 00 19 	add  %o4, %i1, %o4                             
 201e23c:	90 10 00 1b 	mov  %i3, %o0                                  
 201e240:	7f ff cc b2 	call  2011508 <rtems_rfs_group_open>           
 201e244:	b2 06 60 50 	add  %i1, 0x50, %i1                            
                               rtems_rfs_fs_block (fs, group, 0),     
                               fs->group_blocks,                      
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
 201e248:	80 a2 20 00 	cmp  %o0, 0                                    
 201e24c:	04 80 00 1c 	ble  201e2bc <rtems_rfs_fs_open+0x630>         <== ALWAYS TAKEN
 201e250:	ba 10 00 08 	mov  %o0, %i5                                  
 201e254:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 201e258:	10 80 00 07 	b  201e274 <rtems_rfs_fs_open+0x5e8>           <== NOT EXECUTED
 201e25c:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
 201e260:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
 201e264:	92 02 40 18 	add  %o1, %i0, %o1                             <== NOT EXECUTED
 201e268:	7f ff cd 26 	call  2011700 <rtems_rfs_group_close>          <== NOT EXECUTED
 201e26c:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
 201e270:	b0 06 20 50 	add  %i0, 0x50, %i0                            <== NOT EXECUTED
                               fs->group_inodes,                      
                               &fs->groups[group]);                   
    if (rc > 0)                                                       
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
 201e274:	80 a6 40 1a 	cmp  %i1, %i2                                  <== NOT EXECUTED
 201e278:	26 bf ff fa 	bl,a   201e260 <rtems_rfs_fs_open+0x5d4>       <== NOT EXECUTED
 201e27c:	d2 06 e0 20 	ld  [ %i3 + 0x20 ], %o1                        <== NOT EXECUTED
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
      rtems_rfs_buffer_handle_close (fs, &handle);                    
 201e280:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
 201e284:	7f ff fe 65 	call  201dc18 <rtems_rfs_buffer_handle_close>  <== NOT EXECUTED
 201e288:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                     
 201e28c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e290:	7f ff d5 1e 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e294:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e298:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e29c:	22 80 00 0f 	be,a   201e2d8 <rtems_rfs_fs_open+0x64c>       <== NOT EXECUTED
 201e2a0:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
        printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
 201e2a4:	40 00 13 a4 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e2a8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e2ac:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e2b0:	11 00 80 d1 	sethi  %hi(0x2034400), %o0                     <== NOT EXECUTED
 201e2b4:	10 bf ff c0 	b  201e1b4 <rtems_rfs_fs_open+0x528>           <== NOT EXECUTED
 201e2b8:	90 12 23 c8 	or  %o0, 0x3c8, %o0	! 20347c8 <CSWTCH.2+0x12e8><== 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++)                   
 201e2bc:	b4 06 a0 01 	inc  %i2                                       
 201e2c0:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
 201e2c4:	80 a6 80 01 	cmp  %i2, %g1                                  
 201e2c8:	26 bf ff d5 	bl,a   201e21c <rtems_rfs_fs_open+0x590>       
 201e2cc:	fa 06 e0 28 	ld  [ %i3 + 0x28 ], %i5                        
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);  
 201e2d0:	10 80 00 14 	b  201e320 <rtems_rfs_fs_open+0x694>           
 201e2d4:	d0 07 00 00 	ld  [ %i4 ], %o0                               
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
 201e2d8:	22 80 00 12 	be,a   201e320 <rtems_rfs_fs_open+0x694>       <== NOT EXECUTED
 201e2dc:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
 201e2e0:	7f ff f5 c7 	call  201b9fc <rtems_rfs_buffer_close>         <== NOT EXECUTED
 201e2e4:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
 201e2e8:	7f ff a7 3f 	call  2007fe4 <free>                           <== NOT EXECUTED
 201e2ec:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201e2f0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e2f4:	7f ff d5 05 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e2f8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e2fc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e300:	02 bf fe b6 	be  201ddd8 <rtems_rfs_fs_open+0x14c>          <== NOT EXECUTED
 201e304:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: reading superblock: %d: %s\n",        
 201e308:	40 00 13 8b 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e30c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e310:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e314:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e318:	10 bf fe ae 	b  201ddd0 <rtems_rfs_fs_open+0x144>           <== NOT EXECUTED
 201e31c:	90 12 20 08 	or  %o0, 8, %o0	! 2034808 <CSWTCH.2+0x1328>    <== NOT EXECUTED
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);  
 201e320:	92 10 20 01 	mov  1, %o1                                    
 201e324:	94 07 bf d8 	add  %fp, -40, %o2                             
 201e328:	7f ff ce 6f 	call  2011ce4 <rtems_rfs_inode_open>           
 201e32c:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 201e330:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e334:	04 80 00 12 	ble  201e37c <rtems_rfs_fs_open+0x6f0>         <== ALWAYS TAKEN
 201e338:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
 201e33c:	7f ff f5 b0 	call  201b9fc <rtems_rfs_buffer_close>         <== NOT EXECUTED
 201e340:	01 00 00 00 	nop                                            <== NOT EXECUTED
    free (*fs);                                                       
 201e344:	7f ff a7 28 	call  2007fe4 <free>                           <== NOT EXECUTED
 201e348:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201e34c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e350:	7f ff d4 ee 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e354:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e358:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e35c:	02 bf fe 9f 	be  201ddd8 <rtems_rfs_fs_open+0x14c>          <== NOT EXECUTED
 201e360:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: reading root inode: %d: %s\n",        
 201e364:	40 00 13 74 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e368:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e36c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e370:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e374:	10 bf fe 97 	b  201ddd0 <rtems_rfs_fs_open+0x144>           <== NOT EXECUTED
 201e378:	90 12 20 38 	or  %o0, 0x38, %o0	! 2034838 <CSWTCH.2+0x1358> <== NOT EXECUTED
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)                  
 201e37c:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 201e380:	80 88 60 04 	btst  4, %g1                                   
 201e384:	12 80 00 23 	bne  201e410 <rtems_rfs_fs_open+0x784>         
 201e388:	c4 07 bf e4 	ld  [ %fp + -28 ], %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);                    
 201e38c:	c2 08 a0 02 	ldub  [ %g2 + 2 ], %g1                         
 201e390:	c4 08 a0 03 	ldub  [ %g2 + 3 ], %g2                         
 201e394:	83 28 60 08 	sll  %g1, 8, %g1                               
 201e398:	82 10 40 02 	or  %g1, %g2, %g1                              
  {                                                                   
    mode = rtems_rfs_inode_get_mode (&inode);                         
                                                                      
    if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))                
 201e39c:	05 3f ff c0 	sethi  %hi(0xffff0000), %g2                    
 201e3a0:	87 28 60 10 	sll  %g1, 0x10, %g3                            
 201e3a4:	80 a0 c0 02 	cmp  %g3, %g2                                  
 201e3a8:	02 80 00 07 	be  201e3c4 <rtems_rfs_fs_open+0x738>          <== NEVER TAKEN
 201e3ac:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
 201e3b0:	82 08 40 02 	and  %g1, %g2, %g1                             
 201e3b4:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
 201e3b8:	80 a0 40 02 	cmp  %g1, %g2                                  
 201e3bc:	02 80 00 15 	be  201e410 <rtems_rfs_fs_open+0x784>          <== ALWAYS TAKEN
 201e3c0:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_rfs_inode_close (*fs, &inode);                            
 201e3c4:	7f ff ce ba 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201e3c8:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
      rtems_rfs_buffer_close (*fs);                                   
 201e3cc:	7f ff f5 8c 	call  201b9fc <rtems_rfs_buffer_close>         <== NOT EXECUTED
 201e3d0:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      free (*fs);                                                     
 201e3d4:	7f ff a7 04 	call  2007fe4 <free>                           <== NOT EXECUTED
 201e3d8:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                     
 201e3dc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e3e0:	7f ff d4 ca 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e3e4:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e3e8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e3ec:	02 80 00 04 	be  201e3fc <rtems_rfs_fs_open+0x770>          <== NOT EXECUTED
 201e3f0:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
        printf ("rtems-rfs: open: invalid root inode mode\n");        
 201e3f4:	40 00 0f 7c 	call  20221e4 <puts>                           <== NOT EXECUTED
 201e3f8:	90 12 20 68 	or  %o0, 0x68, %o0	! 2034868 <CSWTCH.2+0x1388> <== NOT EXECUTED
      errno = EIO;                                                    
 201e3fc:	40 00 09 89 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201e400:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201e404:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
 201e408:	10 bf fe 77 	b  201dde4 <rtems_rfs_fs_open+0x158>           <== NOT EXECUTED
 201e40c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
      return -1;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (*fs, &inode);                           
 201e410:	7f ff ce a7 	call  2011eac <rtems_rfs_inode_close>          
 201e414:	92 07 bf d8 	add  %fp, -40, %o1                             
  if (rc > 0)                                                         
 201e418:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e41c:	04 80 00 12 	ble  201e464 <rtems_rfs_fs_open+0x7d8>         <== ALWAYS TAKEN
 201e420:	01 00 00 00 	nop                                            
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
 201e424:	7f ff f5 76 	call  201b9fc <rtems_rfs_buffer_close>         <== NOT EXECUTED
 201e428:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
 201e42c:	7f ff a6 ee 	call  2007fe4 <free>                           <== NOT EXECUTED
 201e430:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
 201e434:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e438:	7f ff d4 b4 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e43c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 201e440:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e444:	02 bf fe 65 	be  201ddd8 <rtems_rfs_fs_open+0x14c>          <== NOT EXECUTED
 201e448:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
 201e44c:	40 00 13 3a 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e450:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e454:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e458:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e45c:	10 bf fe 5d 	b  201ddd0 <rtems_rfs_fs_open+0x144>           <== NOT EXECUTED
 201e460:	90 12 20 98 	or  %o0, 0x98, %o0	! 2034898 <CSWTCH.2+0x13b8> <== NOT EXECUTED
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  errno = 0;                                                          
 201e464:	40 00 09 6f 	call  2020a20 <__errno>                        
 201e468:	b0 10 20 00 	clr  %i0                                       
 201e46c:	c0 22 00 00 	clr  [ %o0 ]                                   
  return 0;                                                           
}                                                                     
 201e470:	81 c7 e0 08 	ret                                            
 201e474:	81 e8 00 00 	restore                                        
                                                                      

0201dc40 <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) {
 201dc40:	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;                                         
 201dc44:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           <== NOT EXECUTED
 201dc48:	d6 06 20 04 	ld  [ %i0 + 4 ], %o3                           <== NOT EXECUTED
 201dc4c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201dc50:	40 00 41 fa 	call  202e438 <__muldi3>                       <== NOT EXECUTED
 201dc54:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
}                                                                     
 201dc58:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
 201dc5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201dc60:	93 e8 00 09 	restore  %g0, %o1, %o1                         <== NOT EXECUTED
                                                                      

02011790 <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) {
 2011790:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_bitmap_bit bit;                                           
  int                  offset;                                        
  bool                 updown;                                        
  int                  direction;                                     
                                                                      
  if (inode)                                                          
 2011794:	80 a6 a0 00 	cmp  %i2, 0                                    
 2011798:	02 80 00 05 	be  20117ac <rtems_rfs_group_bitmap_alloc+0x1c>
 201179c:	ba 10 00 18 	mov  %i0, %i5                                  
  {                                                                   
    size = fs->group_inodes;                                          
 20117a0:	e2 06 20 2c 	ld  [ %i0 + 0x2c ], %l1                        
    goal -= RTEMS_RFS_ROOT_INO;                                       
 20117a4:	10 80 00 03 	b  20117b0 <rtems_rfs_group_bitmap_alloc+0x20> 
 20117a8:	b2 06 7f ff 	add  %i1, -1, %i1                              
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
 20117ac:	e2 06 20 28 	ld  [ %i0 + 0x28 ], %l1                        
                                                                      
  group_start = goal / size;                                          
 20117b0:	92 10 00 11 	mov  %l1, %o1                                  
 20117b4:	7f ff c3 b2 	call  200267c <.udiv>                          
 20117b8:	90 10 00 19 	mov  %i1, %o0                                  
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
 20117bc:	92 10 00 11 	mov  %l1, %o1                                  
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
 20117c0:	a8 10 00 08 	mov  %o0, %l4                                  
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
  offset = 0;                                                         
  updown = true;                                                      
  direction = 1;                                                      
 20117c4:	b8 10 20 01 	mov  1, %i4                                    
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
 20117c8:	90 10 00 19 	mov  %i1, %o0                                  
 20117cc:	40 00 72 6f 	call  202e188 <.urem>                          
 20117d0:	a4 10 20 01 	mov  1, %l2                                    
  offset = 0;                                                         
 20117d4:	a0 10 20 00 	clr  %l0                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
 20117d8:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
 20117dc:	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);                       
 20117e0:	90 10 00 1c 	mov  %i4, %o0                                  
 20117e4:	7f ff c3 6c 	call  2002594 <.umul>                          
 20117e8:	92 10 00 10 	mov  %l0, %o1                                  
    if (offset)                                                       
 20117ec:	80 a4 20 00 	cmp  %l0, 0                                    
 20117f0:	02 80 00 07 	be  201180c <rtems_rfs_group_bitmap_alloc+0x7c>
 20117f4:	b2 05 00 08 	add  %l4, %o0, %i1                             
      bit = direction > 0 ? 0 : size - 1;                             
 20117f8:	80 a7 20 00 	cmp  %i4, 0                                    
 20117fc:	14 80 00 03 	bg  2011808 <rtems_rfs_group_bitmap_alloc+0x78>
 2011800:	82 10 20 00 	clr  %g1                                       
 2011804:	82 04 7f ff 	add  %l1, -1, %g1                              
 2011808:	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))                    
 201180c:	80 a6 60 00 	cmp  %i1, 0                                    
 2011810:	06 80 00 07 	bl  201182c <rtems_rfs_group_bitmap_alloc+0x9c>
 2011814:	80 8c a0 ff 	btst  0xff, %l2                                
 2011818:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 201181c:	80 a6 40 01 	cmp  %i1, %g1                                  
 2011820:	26 80 00 0a 	bl,a   2011848 <rtems_rfs_group_bitmap_alloc+0xb8>
 2011824:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
    {                                                                 
      if (!updown)                                                    
 2011828:	80 8c a0 ff 	btst  0xff, %l2                                
 201182c:	02 80 00 50 	be  201196c <rtems_rfs_group_bitmap_alloc+0x1dc>
 2011830:	80 a7 20 00 	cmp  %i4, 0                                    
        break;                                                        
      direction = direction > 0 ? -1 : 1;                             
 2011834:	24 80 00 03 	ble,a   2011840 <rtems_rfs_group_bitmap_alloc+0xb0><== ALWAYS TAKEN
 2011838:	b8 10 20 01 	mov  1, %i4                                    
 201183c:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
      updown = false;                                                 
 2011840:	10 bf ff e7 	b  20117dc <rtems_rfs_group_bitmap_alloc+0x4c> 
 2011844:	a4 10 20 00 	clr  %l2                                       
 2011848:	a7 2e 60 04 	sll  %i1, 4, %l3                               
 201184c:	85 2e 60 06 	sll  %i1, 6, %g2                               
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
 2011850:	80 a6 a0 00 	cmp  %i2, 0                                    
      bitmap = &fs->groups[group].inode_bitmap;                       
 2011854:	a6 04 c0 02 	add  %l3, %g2, %l3                             
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
 2011858:	02 80 00 04 	be  2011868 <rtems_rfs_group_bitmap_alloc+0xd8>
 201185c:	a6 00 40 13 	add  %g1, %l3, %l3                             
      bitmap = &fs->groups[group].inode_bitmap;                       
 2011860:	10 80 00 03 	b  201186c <rtems_rfs_group_bitmap_alloc+0xdc> 
 2011864:	a6 04 e0 2c 	add  %l3, 0x2c, %l3                            
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
 2011868:	a6 04 e0 08 	add  %l3, 8, %l3                               
                                                                      
    rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);  
 201186c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
 2011870:	90 10 00 13 	mov  %l3, %o0                                  
 2011874:	94 07 bf fb 	add  %fp, -5, %o2                              
 2011878:	40 00 21 62 	call  2019e00 <rtems_rfs_bitmap_map_alloc>     
 201187c:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc > 0)                                                       
 2011880:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2011884:	14 80 00 45 	bg  2011998 <rtems_rfs_group_bitmap_alloc+0x208><== NEVER TAKEN
 2011888:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    if (rtems_rfs_fs_release_bitmaps (fs))                            
 201188c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 2011890:	80 88 60 01 	btst  1, %g1                                   
 2011894:	12 80 00 06 	bne  20118ac <rtems_rfs_group_bitmap_alloc+0x11c><== NEVER TAKEN
 2011898:	c2 0f bf fb 	ldub  [ %fp + -5 ], %g1                        
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
 201189c:	d2 04 c0 00 	ld  [ %l3 ], %o1                               
 20118a0:	40 00 26 62 	call  201b228 <rtems_rfs_buffer_handle_release>
 20118a4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if (allocated)                                                    
 20118a8:	c2 0f bf fb 	ldub  [ %fp + -5 ], %g1                        
 20118ac:	80 a0 60 00 	cmp  %g1, 0                                    
 20118b0:	02 80 00 27 	be  201194c <rtems_rfs_group_bitmap_alloc+0x1bc>
 20118b4:	80 8c a0 ff 	btst  0xff, %l2                                
    {                                                                 
      if (inode)                                                      
 20118b8:	80 a6 a0 00 	cmp  %i2, 0                                    
 20118bc:	02 80 00 09 	be  20118e0 <rtems_rfs_group_bitmap_alloc+0x150>
 20118c0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        *result = rtems_rfs_group_inode (fs, group, bit);             
 20118c4:	d2 07 60 2c 	ld  [ %i5 + 0x2c ], %o1                        
 20118c8:	b8 00 60 01 	add  %g1, 1, %i4                               
 20118cc:	7f ff c3 32 	call  2002594 <.umul>                          
 20118d0:	90 10 00 19 	mov  %i1, %o0                                  
 20118d4:	90 07 00 08 	add  %i4, %o0, %o0                             
 20118d8:	10 80 00 09 	b  20118fc <rtems_rfs_group_bitmap_alloc+0x16c>
 20118dc:	d0 26 c0 00 	st  %o0, [ %i3 ]                               
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
 20118e0:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
 20118e4:	87 2e 60 04 	sll  %i1, 4, %g3                               
 20118e8:	b3 2e 60 06 	sll  %i1, 6, %i1                               
 20118ec:	b2 00 c0 19 	add  %g3, %i1, %i1                             
 20118f0:	c4 00 80 19 	ld  [ %g2 + %i1 ], %g2                         
 20118f4:	82 00 40 02 	add  %g1, %g2, %g1                             
 20118f8:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
 20118fc:	90 10 20 00 	clr  %o0                                       
 2011900:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
 2011904:	40 00 07 81 	call  2013708 <rtems_rfs_trace>                
 2011908:	b0 10 20 00 	clr  %i0                                       
 201190c:	80 8a 20 ff 	btst  0xff, %o0                                
 2011910:	02 80 00 0d 	be  2011944 <rtems_rfs_group_bitmap_alloc+0x1b4><== ALWAYS TAKEN
 2011914:	80 a6 a0 00 	cmp  %i2, 0                                    
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
 2011918:	22 80 00 05 	be,a   201192c <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
 201191c:	13 00 80 ca 	sethi  %hi(0x2032800), %o1                     <== NOT EXECUTED
 2011920:	13 00 80 ca 	sethi  %hi(0x2032800), %o1                     <== NOT EXECUTED
 2011924:	10 80 00 03 	b  2011930 <rtems_rfs_group_bitmap_alloc+0x1a0><== NOT EXECUTED
 2011928:	92 12 62 48 	or  %o1, 0x248, %o1	! 2032a48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
 201192c:	92 12 62 50 	or  %o1, 0x250, %o1                            <== NOT EXECUTED
 2011930:	d4 06 c0 00 	ld  [ %i3 ], %o2                               <== NOT EXECUTED
 2011934:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
                inode ? "inode" : "block", *result);                  
      return 0;                                                       
 2011938:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
      if (inode)                                                      
        *result = rtems_rfs_group_inode (fs, group, bit);             
      else                                                            
        *result = rtems_rfs_group_block (&fs->groups[group], bit);    
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
 201193c:	40 00 41 92 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011940:	90 12 22 58 	or  %o0, 0x258, %o0                            <== NOT EXECUTED
 2011944:	81 c7 e0 08 	ret                                            
 2011948:	81 e8 00 00 	restore                                        
                inode ? "inode" : "block", *result);                  
      return 0;                                                       
    }                                                                 
                                                                      
    if (updown)                                                       
 201194c:	22 bf ff a4 	be,a   20117dc <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
 2011950:	a0 04 20 01 	inc  %l0                                       <== NOT EXECUTED
      direction = direction > 0 ? -1 : 1;                             
 2011954:	80 a7 20 00 	cmp  %i4, 0                                    
 2011958:	24 80 00 03 	ble,a   2011964 <rtems_rfs_group_bitmap_alloc+0x1d4><== NEVER TAKEN
 201195c:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
 2011960:	b8 10 3f ff 	mov  -1, %i4                                   
                                                                      
    offset++;                                                         
 2011964:	10 bf ff 9e 	b  20117dc <rtems_rfs_group_bitmap_alloc+0x4c> 
 2011968:	a0 04 20 01 	inc  %l0                                       
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
 201196c:	90 10 20 00 	clr  %o0                                       
 2011970:	40 00 07 66 	call  2013708 <rtems_rfs_trace>                
 2011974:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
 2011978:	80 8a 20 ff 	btst  0xff, %o0                                
 201197c:	12 80 00 04 	bne  201198c <rtems_rfs_group_bitmap_alloc+0x1fc><== NEVER TAKEN
 2011980:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     
    printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");  
                                                                      
  return ENOSPC;                                                      
 2011984:	81 c7 e0 08 	ret                                            
 2011988:	91 e8 20 1c 	restore  %g0, 0x1c, %o0                        
                                                                      
    offset++;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
    printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");  
 201198c:	40 00 42 16 	call  20221e4 <puts>                           <== NOT EXECUTED
 2011990:	90 12 22 90 	or  %o0, 0x290, %o0                            <== NOT EXECUTED
                                                                      
  return ENOSPC;                                                      
 2011994:	b0 10 20 1c 	mov  0x1c, %i0                                 <== NOT EXECUTED
}                                                                     
 2011998:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201199c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020119a0 <rtems_rfs_group_bitmap_free>: int rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs, bool inode, rtems_rfs_bitmap_bit no) {
 20119a0:	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))                
 20119a4:	90 10 20 00 	clr  %o0                                       
 20119a8:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
 20119ac:	40 00 07 57 	call  2013708 <rtems_rfs_trace>                
 20119b0:	ba 10 00 18 	mov  %i0, %i5                                  
 20119b4:	80 8a 20 ff 	btst  0xff, %o0                                
 20119b8:	02 80 00 0d 	be  20119ec <rtems_rfs_group_bitmap_free+0x4c> <== ALWAYS TAKEN
 20119bc:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",   
 20119c0:	22 80 00 05 	be,a   20119d4 <rtems_rfs_group_bitmap_free+0x34><== NOT EXECUTED
 20119c4:	13 00 80 ca 	sethi  %hi(0x2032800), %o1                     <== NOT EXECUTED
 20119c8:	13 00 80 ca 	sethi  %hi(0x2032800), %o1                     <== NOT EXECUTED
 20119cc:	10 80 00 03 	b  20119d8 <rtems_rfs_group_bitmap_free+0x38>  <== NOT EXECUTED
 20119d0:	92 12 62 48 	or  %o1, 0x248, %o1	! 2032a48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
 20119d4:	92 12 62 50 	or  %o1, 0x250, %o1                            <== NOT EXECUTED
 20119d8:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 20119dc:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 20119e0:	40 00 41 69 	call  2021f84 <printf>                         <== NOT EXECUTED
 20119e4:	90 12 22 c8 	or  %o0, 0x2c8, %o0                            <== NOT EXECUTED
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
 20119e8:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
 20119ec:	02 80 00 04 	be  20119fc <rtems_rfs_group_bitmap_free+0x5c> 
 20119f0:	b4 06 bf ff 	add  %i2, -1, %i2                              
  {                                                                   
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
 20119f4:	10 80 00 03 	b  2011a00 <rtems_rfs_group_bitmap_free+0x60>  
 20119f8:	f6 07 60 2c 	ld  [ %i5 + 0x2c ], %i3                        
  }                                                                   
  else                                                                
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
 20119fc:	f6 07 60 28 	ld  [ %i5 + 0x28 ], %i3                        
  }                                                                   
                                                                      
  group = no / size;                                                  
 2011a00:	92 10 00 1b 	mov  %i3, %o1                                  
 2011a04:	7f ff c3 1e 	call  200267c <.udiv>                          
 2011a08:	90 10 00 1a 	mov  %i2, %o0                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
 2011a0c:	92 10 00 1b 	mov  %i3, %o1                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
 2011a10:	b0 10 00 08 	mov  %o0, %i0                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
 2011a14:	40 00 71 dd 	call  202e188 <.urem>                          
 2011a18:	90 10 00 1a 	mov  %i2, %o0                                  
 2011a1c:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 2011a20:	b9 2e 20 04 	sll  %i0, 4, %i4                               
 2011a24:	92 10 00 08 	mov  %o0, %o1                                  
 2011a28:	b1 2e 20 06 	sll  %i0, 6, %i0                               
                                                                      
  if (inode)                                                          
 2011a2c:	80 a6 60 00 	cmp  %i1, 0                                    
    bitmap = &fs->groups[group].inode_bitmap;                         
 2011a30:	b8 07 00 18 	add  %i4, %i0, %i4                             
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
 2011a34:	02 80 00 04 	be  2011a44 <rtems_rfs_group_bitmap_free+0xa4> 
 2011a38:	b8 00 40 1c 	add  %g1, %i4, %i4                             
    bitmap = &fs->groups[group].inode_bitmap;                         
 2011a3c:	10 80 00 03 	b  2011a48 <rtems_rfs_group_bitmap_free+0xa8>  
 2011a40:	b8 07 20 2c 	add  %i4, 0x2c, %i4                            
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
 2011a44:	b8 07 20 08 	add  %i4, 8, %i4                               
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
 2011a48:	40 00 20 62 	call  2019bd0 <rtems_rfs_bitmap_map_clear>     
 2011a4c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
 2011a50:	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);                      
 2011a54:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
 2011a58:	40 00 25 f4 	call  201b228 <rtems_rfs_buffer_handle_release>
 2011a5c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return rc;                                                          
}                                                                     
 2011a60:	81 c7 e0 08 	ret                                            
 2011a64:	81 e8 00 00 	restore                                        
                                                                      

02011a68 <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) {
 2011a68:	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))                
 2011a6c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 2011a70:	13 00 00 80 	sethi  %hi(0x20000), %o1                       <== NOT EXECUTED
 2011a74:	40 00 07 25 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 2011a78:	ba 10 00 18 	mov  %i0, %i5                                  <== NOT EXECUTED
 2011a7c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2011a80:	02 80 00 0d 	be  2011ab4 <rtems_rfs_group_bitmap_test+0x4c> <== NOT EXECUTED
 2011a84:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
 2011a88:	22 80 00 05 	be,a   2011a9c <rtems_rfs_group_bitmap_test+0x34><== NOT EXECUTED
 2011a8c:	13 00 80 ca 	sethi  %hi(0x2032800), %o1                     <== NOT EXECUTED
 2011a90:	13 00 80 ca 	sethi  %hi(0x2032800), %o1                     <== NOT EXECUTED
 2011a94:	10 80 00 03 	b  2011aa0 <rtems_rfs_group_bitmap_test+0x38>  <== NOT EXECUTED
 2011a98:	92 12 62 48 	or  %o1, 0x248, %o1	! 2032a48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
 2011a9c:	92 12 62 50 	or  %o1, 0x250, %o1                            <== NOT EXECUTED
 2011aa0:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011aa4:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 2011aa8:	40 00 41 37 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011aac:	90 12 22 f8 	or  %o0, 0x2f8, %o0                            <== NOT EXECUTED
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
 2011ab0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
 2011ab4:	22 80 00 0b 	be,a   2011ae0 <rtems_rfs_group_bitmap_test+0x78><== NOT EXECUTED
 2011ab8:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           <== NOT EXECUTED
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
 2011abc:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
 2011ac0:	04 80 00 25 	ble  2011b54 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
 2011ac4:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
 2011ac8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
 2011acc:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
 2011ad0:	18 80 00 21 	bgu  2011b54 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
 2011ad4:	b4 06 bf ff 	add  %i2, -1, %i2                              <== NOT EXECUTED
        return EINVAL;                                                
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
 2011ad8:	10 80 00 06 	b  2011af0 <rtems_rfs_group_bitmap_test+0x88>  <== NOT EXECUTED
 2011adc:	f0 07 60 2c 	ld  [ %i5 + 0x2c ], %i0                        <== NOT EXECUTED
  }                                                                   
  else                                                                
  {                                                                   
    if (no >= rtems_rfs_fs_blocks (fs))                               
 2011ae0:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
 2011ae4:	1a 80 00 1c 	bcc  2011b54 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
 2011ae8:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
        return EINVAL;                                                
    size = fs->group_blocks;                                          
 2011aec:	f0 07 60 28 	ld  [ %i5 + 0x28 ], %i0                        <== NOT EXECUTED
  }                                                                   
                                                                      
  group = no / size;                                                  
 2011af0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
 2011af4:	7f ff c2 e2 	call  200267c <.udiv>                          <== NOT EXECUTED
 2011af8:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
 2011afc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
    if (no >= rtems_rfs_fs_blocks (fs))                               
        return EINVAL;                                                
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
 2011b00:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
 2011b04:	40 00 71 a1 	call  202e188 <.urem>                          <== NOT EXECUTED
 2011b08:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
 2011b0c:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        <== NOT EXECUTED
 2011b10:	b9 2c 20 04 	sll  %l0, 4, %i4                               <== NOT EXECUTED
 2011b14:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 2011b18:	a1 2c 20 06 	sll  %l0, 6, %l0                               <== NOT EXECUTED
                                                                      
  if (inode)                                                          
 2011b1c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
    bitmap = &fs->groups[group].inode_bitmap;                         
 2011b20:	b8 07 00 10 	add  %i4, %l0, %i4                             <== NOT EXECUTED
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
 2011b24:	02 80 00 04 	be  2011b34 <rtems_rfs_group_bitmap_test+0xcc> <== NOT EXECUTED
 2011b28:	b8 00 40 1c 	add  %g1, %i4, %i4                             <== NOT EXECUTED
    bitmap = &fs->groups[group].inode_bitmap;                         
 2011b2c:	10 80 00 03 	b  2011b38 <rtems_rfs_group_bitmap_test+0xd0>  <== NOT EXECUTED
 2011b30:	b8 07 20 2c 	add  %i4, 0x2c, %i4                            <== NOT EXECUTED
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
 2011b34:	b8 07 20 08 	add  %i4, 8, %i4                               <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
 2011b38:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 2011b3c:	40 00 20 48 	call  2019c5c <rtems_rfs_bitmap_map_test>      <== NOT EXECUTED
 2011b40:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
 2011b44:	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);                
 2011b48:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
 2011b4c:	40 00 25 b7 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 2011b50:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
 2011b54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2011b58:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02011700 <rtems_rfs_group_close>: int rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group) {
 2011700:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))                  
 2011704:	90 10 20 00 	clr  %o0                                       
 2011708:	13 00 00 40 	sethi  %hi(0x10000), %o1                       
 201170c:	40 00 07 ff 	call  2013708 <rtems_rfs_trace>                
 2011710:	ba 10 00 18 	mov  %i0, %i5                                  
 2011714:	80 8a 20 ff 	btst  0xff, %o0                                
 2011718:	02 80 00 06 	be  2011730 <rtems_rfs_group_close+0x30>       <== ALWAYS TAKEN
 201171c:	01 00 00 00 	nop                                            
    printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
 2011720:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 2011724:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011728:	40 00 42 17 	call  2021f84 <printf>                         <== NOT EXECUTED
 201172c:	90 12 22 20 	or  %o0, 0x220, %o0	! 2032a20 <_CPU_Trap_slot_template+0x9e8><== 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);                 
 2011730:	40 00 22 3f 	call  201a02c <rtems_rfs_bitmap_close>         
 2011734:	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);                       
 2011738:	92 06 60 44 	add  %i1, 0x44, %o1                            
 201173c:	b8 10 00 08 	mov  %o0, %i4                                  
 2011740:	40 00 26 ba 	call  201b228 <rtems_rfs_buffer_handle_release>
 2011744:	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);                 
 2011748:	90 06 60 08 	add  %i1, 8, %o0                               
  handle->dirty = false;                                              
 201174c:	c0 2e 60 44 	clrb  [ %i1 + 0x44 ]                           
  handle->bnum  = 0;                                                  
 2011750:	c0 26 60 48 	clr  [ %i1 + 0x48 ]                            
 2011754:	40 00 22 36 	call  201a02c <rtems_rfs_bitmap_close>         
 2011758:	c0 26 60 4c 	clr  [ %i1 + 0x4c ]                            
  if (rc > 0)                                                         
 201175c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2011760:	14 80 00 05 	bg  2011774 <rtems_rfs_group_close+0x74>       <== NEVER TAKEN
 2011764:	90 10 00 1d 	mov  %i5, %o0                                  
 2011768:	b0 38 00 1c 	xnor  %g0, %i4, %i0                            
 201176c:	b1 3e 20 1f 	sra  %i0, 0x1f, %i0                            
 2011770:	b0 0f 00 18 	and  %i4, %i0, %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);                       
 2011774:	40 00 26 ad 	call  201b228 <rtems_rfs_buffer_handle_release>
 2011778:	92 06 60 20 	add  %i1, 0x20, %o1                            
  handle->dirty = false;                                              
 201177c:	c0 2e 60 20 	clrb  [ %i1 + 0x20 ]                           
  handle->bnum  = 0;                                                  
 2011780:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
  handle->buffer = NULL;                                              
 2011784:	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;                                                      
}                                                                     
 2011788:	81 c7 e0 08 	ret                                            
 201178c:	81 e8 00 00 	restore                                        
                                                                      

02011508 <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) {
 2011508:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (base >= rtems_rfs_fs_blocks (fs))                               
 201150c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 2011510:	80 a6 40 01 	cmp  %i1, %g1                                  
 2011514:	0a 80 00 10 	bcs  2011554 <rtems_rfs_group_open+0x4c>       <== ALWAYS TAKEN
 2011518:	84 06 80 19 	add  %i2, %i1, %g2                             
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
 201151c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 2011520:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
 2011524:	40 00 08 79 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 2011528:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
 201152c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2011530:	22 80 00 72 	be,a   20116f8 <rtems_rfs_group_open+0x1f0>    <== NOT EXECUTED
 2011534:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
      printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
 2011538:	40 00 46 ff 	call  2023134 <strerror>                       <== NOT EXECUTED
 201153c:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
 2011540:	92 10 20 05 	mov  5, %o1                                    <== NOT EXECUTED
 2011544:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011548:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 201154c:	10 80 00 36 	b  2011624 <rtems_rfs_group_open+0x11c>        <== NOT EXECUTED
 2011550:	90 12 21 28 	or  %o0, 0x128, %o0	! 2032928 <_CPU_Trap_slot_template+0x8f0><== NOT EXECUTED
              EIO, strerror (EIO));                                   
    return EIO;                                                       
  }                                                                   
                                                                      
  if ((base + size) >= rtems_rfs_fs_blocks (fs))                      
 2011554:	80 a0 80 01 	cmp  %g2, %g1                                  
 2011558:	3a 80 00 02 	bcc,a   2011560 <rtems_rfs_group_open+0x58>    <== ALWAYS TAKEN
 201155c:	b4 20 40 19 	sub  %g1, %i1, %i2                             
 2011560:	80 a6 80 1b 	cmp  %i2, %i3                                  
 2011564:	08 80 00 03 	bleu  2011570 <rtems_rfs_group_open+0x68>      <== NEVER TAKEN
 2011568:	a0 10 00 1a 	mov  %i2, %l0                                  
 201156c:	a0 10 00 1b 	mov  %i3, %l0                                  
   * the format configuration needs reviewing.                        
   */                                                                 
  if (inodes > size)                                                  
    inodes = size;                                                    
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                   
 2011570:	90 10 20 00 	clr  %o0                                       
 2011574:	40 00 08 65 	call  2013708 <rtems_rfs_trace>                
 2011578:	13 00 00 20 	sethi  %hi(0x8000), %o1                        
 201157c:	80 8a 20 ff 	btst  0xff, %o0                                
 2011580:	22 80 00 09 	be,a   20115a4 <rtems_rfs_group_open+0x9c>     <== ALWAYS TAKEN
 2011584:	f2 27 00 00 	st  %i1, [ %i4 ]                               
    printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
 2011588:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 201158c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2011590:	90 12 21 68 	or  %o0, 0x168, %o0                            <== NOT EXECUTED
 2011594:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 2011598:	40 00 42 7b 	call  2021f84 <printf>                         <== NOT EXECUTED
 201159c:	96 10 00 10 	mov  %l0, %o3                                  <== NOT EXECUTED
            base, size, inodes);                                      
                                                                      
  group->base = base;                                                 
 20115a0:	f2 27 00 00 	st  %i1, [ %i4 ]                               <== NOT EXECUTED
  group->size = size;                                                 
 20115a4:	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;                                              
 20115a8:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           
  handle->bnum  = 0;                                                  
 20115ac:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            
  handle->buffer = NULL;                                              
 20115b0:	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,               
 20115b4:	a2 07 20 08 	add  %i4, 8, %l1                               
 20115b8:	b6 07 20 20 	add  %i4, 0x20, %i3                            
 20115bc:	90 10 00 11 	mov  %l1, %o0                                  
 20115c0:	92 10 00 18 	mov  %i0, %o1                                  
 20115c4:	94 10 00 1b 	mov  %i3, %o2                                  
 20115c8:	96 10 00 1a 	mov  %i2, %o3                                  
 20115cc:	40 00 22 87 	call  2019fe8 <rtems_rfs_bitmap_open>          
 20115d0:	98 10 00 19 	mov  %i1, %o4                                  
                              &group->block_bitmap_buffer, size,      
                              group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
 20115d4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20115d8:	04 80 00 16 	ble  2011630 <rtems_rfs_group_open+0x128>      <== ALWAYS TAKEN
 20115dc:	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);                       
 20115e0:	40 00 27 12 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 20115e4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);  
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
 20115e8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  handle->dirty = false;                                              
 20115ec:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 20115f0:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 20115f4:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            <== NOT EXECUTED
 20115f8:	40 00 08 44 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 20115fc:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
 2011600:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2011604:	22 80 00 3d 	be,a   20116f8 <rtems_rfs_group_open+0x1f0>    <== NOT EXECUTED
 2011608:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
 201160c:	40 00 46 ca 	call  2023134 <strerror>                       <== NOT EXECUTED
 2011610:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2011614:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2011618:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 201161c:	90 12 21 a0 	or  %o0, 0x1a0, %o0	! 20329a0 <_CPU_Trap_slot_template+0x968><== NOT EXECUTED
 2011620:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 2011624:	40 00 42 58 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011628:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 201162c:	30 80 00 33 	b,a   20116f8 <rtems_rfs_group_open+0x1f0>     <== 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,               
 2011630:	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;                                              
 2011634:	c0 2f 20 44 	clrb  [ %i4 + 0x44 ]                           
  handle->bnum  = 0;                                                  
 2011638:	c0 27 20 48 	clr  [ %i4 + 0x48 ]                            
  handle->buffer = NULL;                                              
 201163c:	c0 27 20 4c 	clr  [ %i4 + 0x4c ]                            
 2011640:	b4 07 20 44 	add  %i4, 0x44, %i2                            
 2011644:	90 07 20 2c 	add  %i4, 0x2c, %o0                            
 2011648:	92 10 00 18 	mov  %i0, %o1                                  
 201164c:	94 10 00 1a 	mov  %i2, %o2                                  
 2011650:	96 10 00 10 	mov  %l0, %o3                                  
 2011654:	40 00 22 65 	call  2019fe8 <rtems_rfs_bitmap_open>          
 2011658:	98 03 20 01 	inc  %o4                                       
                              &group->inode_bitmap_buffer, inodes,    
                              group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
 201165c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2011660:	04 80 00 1b 	ble  20116cc <rtems_rfs_group_open+0x1c4>      <== ALWAYS TAKEN
 2011664:	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);                       
 2011668:	40 00 26 f0 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201166c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);  
    rtems_rfs_bitmap_close (&group->block_bitmap);                    
 2011670:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
 2011674:	c0 2f 20 44 	clrb  [ %i4 + 0x44 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 2011678:	c0 27 20 48 	clr  [ %i4 + 0x48 ]                            <== NOT EXECUTED
 201167c:	40 00 22 6c 	call  201a02c <rtems_rfs_bitmap_close>         <== NOT EXECUTED
 2011680:	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);                       
 2011684:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 2011688:	40 00 26 e8 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201168c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);  
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))                 
 2011690:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  handle->dirty = false;                                              
 2011694:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 2011698:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201169c:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            <== NOT EXECUTED
 20116a0:	40 00 08 1a 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 20116a4:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
 20116a8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 20116ac:	22 80 00 13 	be,a   20116f8 <rtems_rfs_group_open+0x1f0>    <== NOT EXECUTED
 20116b0:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
 20116b4:	40 00 46 a0 	call  2023134 <strerror>                       <== NOT EXECUTED
 20116b8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20116bc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 20116c0:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 20116c4:	10 bf ff d7 	b  2011620 <rtems_rfs_group_open+0x118>        <== NOT EXECUTED
 20116c8:	90 12 21 e0 	or  %o0, 0x1e0, %o0	! 20329e0 <_CPU_Trap_slot_template+0x9a8><== NOT EXECUTED
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  if (rtems_rfs_fs_release_bitmaps (fs))                              
 20116cc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 20116d0:	80 88 60 01 	btst  1, %g1                                   
 20116d4:	12 80 00 08 	bne  20116f4 <rtems_rfs_group_open+0x1ec>      <== NEVER TAKEN
 20116d8:	ba 10 20 00 	clr  %i5                                       
  {                                                                   
    rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);       
 20116dc:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
 20116e0:	40 00 26 d2 	call  201b228 <rtems_rfs_buffer_handle_release>
 20116e4:	90 10 00 18 	mov  %i0, %o0                                  
    rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);       
 20116e8:	d2 07 20 2c 	ld  [ %i4 + 0x2c ], %o1                        
 20116ec:	40 00 26 cf 	call  201b228 <rtems_rfs_buffer_handle_release>
 20116f0:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 20116f4:	b0 10 00 1d 	mov  %i5, %i0                                  
 20116f8:	81 c7 e0 08 	ret                                            
 20116fc:	81 e8 00 00 	restore                                        
                                                                      

02011b5c <rtems_rfs_group_usage>: size_t* blocks, size_t* inodes) { int g; *blocks = 0;
 2011b5c:	c0 22 40 00 	clr  [ %o1 ]                                   <== NOT EXECUTED
  *inodes = 0;                                                        
 2011b60:	c0 22 80 00 	clr  [ %o2 ]                                   <== NOT EXECUTED
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
 2011b64:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
 2011b68:	10 80 00 11 	b  2011bac <rtems_rfs_group_usage+0x50>        <== NOT EXECUTED
 2011b6c:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
 2011b70:	c2 02 20 20 	ld  [ %o0 + 0x20 ], %g1                        <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
 2011b74:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
 2011b78:	82 00 40 03 	add  %g1, %g3, %g1                             <== NOT EXECUTED
    *blocks +=                                                        
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
 2011b7c:	d8 00 60 14 	ld  [ %g1 + 0x14 ], %o4                        <== NOT EXECUTED
 2011b80:	da 00 60 18 	ld  [ %g1 + 0x18 ], %o5                        <== NOT EXECUTED
 2011b84:	86 00 e0 50 	add  %g3, 0x50, %g3                            <== NOT EXECUTED
 2011b88:	9a 23 00 0d 	sub  %o4, %o5, %o5                             <== NOT EXECUTED
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
 2011b8c:	88 01 00 0d 	add  %g4, %o5, %g4                             <== NOT EXECUTED
 2011b90:	c8 22 40 00 	st  %g4, [ %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) -              
 2011b94:	c8 00 60 38 	ld  [ %g1 + 0x38 ], %g4                        <== NOT EXECUTED
 2011b98:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        <== NOT EXECUTED
 2011b9c:	82 21 00 01 	sub  %g4, %g1, %g1                             <== 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 +=                                                        
 2011ba0:	c8 02 80 00 	ld  [ %o2 ], %g4                               <== NOT EXECUTED
 2011ba4:	82 01 00 01 	add  %g4, %g1, %g1                             <== NOT EXECUTED
 2011ba8:	c2 22 80 00 	st  %g1, [ %o2 ]                               <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
 2011bac:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        <== NOT EXECUTED
 2011bb0:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
 2011bb4:	06 bf ff ef 	bl  2011b70 <rtems_rfs_group_usage+0x14>       <== NOT EXECUTED
 2011bb8:	c8 02 40 00 	ld  [ %o1 ], %g4                               <== 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))                             
 2011bbc:	c4 02 20 04 	ld  [ %o0 + 4 ], %g2                           <== NOT EXECUTED
 2011bc0:	80 a1 00 02 	cmp  %g4, %g2                                  <== NOT EXECUTED
 2011bc4:	08 80 00 03 	bleu  2011bd0 <rtems_rfs_group_usage+0x74>     <== NOT EXECUTED
 2011bc8:	82 10 00 04 	mov  %g4, %g1                                  <== NOT EXECUTED
 2011bcc:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
 2011bd0:	c2 22 40 00 	st  %g1, [ %o1 ]                               <== NOT EXECUTED
    *blocks = rtems_rfs_fs_blocks (fs);                               
  if (*inodes > rtems_rfs_fs_inodes (fs))                             
 2011bd4:	c4 02 20 14 	ld  [ %o0 + 0x14 ], %g2                        <== NOT EXECUTED
 2011bd8:	c2 02 80 00 	ld  [ %o2 ], %g1                               <== NOT EXECUTED
 2011bdc:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 2011be0:	38 80 00 02 	bgu,a   2011be8 <rtems_rfs_group_usage+0x8c>   <== NOT EXECUTED
 2011be4:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
 2011be8:	c2 22 80 00 	st  %g1, [ %o2 ]                               <== NOT EXECUTED
    *inodes = rtems_rfs_fs_inodes (fs);                               
                                                                      
  return 0;                                                           
}                                                                     
 2011bec:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2011bf0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      

02011eac <rtems_rfs_inode_close>: } int rtems_rfs_inode_close (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
 2011eac:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                  
 2011eb0:	90 10 20 00 	clr  %o0                                       
 2011eb4:	40 00 06 15 	call  2013708 <rtems_rfs_trace>                
 2011eb8:	13 00 02 00 	sethi  %hi(0x80000), %o1                       
 2011ebc:	80 8a 20 ff 	btst  0xff, %o0                                
 2011ec0:	22 80 00 07 	be,a   2011edc <rtems_rfs_inode_close+0x30>    <== ALWAYS TAKEN
 2011ec4:	90 10 00 18 	mov  %i0, %o0                                  
    printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
 2011ec8:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 2011ecc:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011ed0:	40 00 40 2d 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011ed4:	90 12 23 c8 	or  %o0, 0x3c8, %o0	! 2032bc8 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_unload (fs, handle, true);                     
 2011ed8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2011edc:	92 10 00 19 	mov  %i1, %o1                                  
 2011ee0:	7f ff ff b7 	call  2011dbc <rtems_rfs_inode_unload>         
 2011ee4:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  if ((rc == 0) && (handle->loads > 0))                               
 2011ee8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2011eec:	32 80 00 11 	bne,a   2011f30 <rtems_rfs_inode_close+0x84>   <== NEVER TAKEN
 2011ef0:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
 2011ef4:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
 2011ef8:	80 a0 60 00 	cmp  %g1, 0                                    
 2011efc:	04 80 00 0c 	ble  2011f2c <rtems_rfs_inode_close+0x80>      <== ALWAYS TAKEN
 2011f00:	13 00 02 00 	sethi  %hi(0x80000), %o1                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                
 2011f04:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 2011f08:	40 00 06 00 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 2011f0c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 2011f10:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2011f14:	22 80 00 07 	be,a   2011f30 <rtems_rfs_inode_close+0x84>    <== NOT EXECUTED
 2011f18:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
      printf ("rtems-rfs: inode-close: bad loads number: %d\n",       
 2011f1c:	d2 06 60 24 	ld  [ %i1 + 0x24 ], %o1                        <== NOT EXECUTED
 2011f20:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011f24:	40 00 40 18 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011f28:	90 12 23 f0 	or  %o0, 0x3f0, %o0	! 2032bf0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
              handle->loads);                                         
    rc = EIO;                                                         
  }                                                                   
                                                                      
  handle->ino = 0;                                                    
 2011f2c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
  return rc;                                                          
}                                                                     
 2011f30:	81 c7 e0 08 	ret                                            
 2011f34:	81 e8 00 00 	restore                                        
                                                                      

02012200 <rtems_rfs_inode_create>: uint16_t mode, uint16_t links, uid_t uid, gid_t gid, rtems_rfs_ino* ino) {
 2012200:	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))                 
 2012204:	90 10 20 00 	clr  %o0                                       
                        uint16_t                mode,                 
                        uint16_t                links,                
                        uid_t                   uid,                  
                        gid_t                   gid,                  
                        rtems_rfs_ino*          ino)                  
{                                                                     
 2012208:	e2 07 a0 64 	ld  [ %fp + 0x64 ], %l1                        
 201220c:	e8 17 a0 5e 	lduh  [ %fp + 0x5e ], %l4                      
 2012210:	e6 17 a0 62 	lduh  [ %fp + 0x62 ], %l3                      
  rtems_rfs_inode_handle parent_inode;                                
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))                 
 2012214:	40 00 05 3d 	call  2013708 <rtems_rfs_trace>                
 2012218:	13 00 10 00 	sethi  %hi(0x400000), %o1                      
 201221c:	80 8a 20 ff 	btst  0xff, %o0                                
 2012220:	02 80 00 36 	be  20122f8 <rtems_rfs_inode_create+0xf8>      <== ALWAYS TAKEN
 2012224:	a4 0f 30 00 	and  %i4, -4096, %l2                           
  {                                                                   
    const char* type = "unknown";                                     
    int         c;                                                    
    if (RTEMS_RFS_S_ISDIR (mode))                                     
 2012228:	82 0f 30 00 	and  %i4, -4096, %g1                           <== NOT EXECUTED
 201222c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        <== NOT EXECUTED
 2012230:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 2012234:	02 80 00 11 	be  2012278 <rtems_rfs_inode_create+0x78>      <== NOT EXECUTED
 2012238:	05 00 00 08 	sethi  %hi(0x2000), %g2                        <== NOT EXECUTED
      type = "dir";                                                   
    else if (RTEMS_RFS_S_ISCHR (mode))                                
 201223c:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 2012240:	02 80 00 11 	be  2012284 <rtems_rfs_inode_create+0x84>      <== NOT EXECUTED
 2012244:	05 00 00 18 	sethi  %hi(0x6000), %g2                        <== NOT EXECUTED
      type = "char";                                                  
    else if (RTEMS_RFS_S_ISBLK (mode))                                
 2012248:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 201224c:	02 80 00 11 	be  2012290 <rtems_rfs_inode_create+0x90>      <== NOT EXECUTED
 2012250:	05 00 00 20 	sethi  %hi(0x8000), %g2                        <== NOT EXECUTED
      type = "block";                                                 
    else if (RTEMS_RFS_S_ISREG (mode))                                
 2012254:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 2012258:	02 80 00 11 	be  201229c <rtems_rfs_inode_create+0x9c>      <== NOT EXECUTED
 201225c:	05 00 00 28 	sethi  %hi(0xa000), %g2                        <== NOT EXECUTED
      type = "file";                                                  
    else if (RTEMS_RFS_S_ISLNK (mode))                                
 2012260:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
 2012264:	22 80 00 11 	be,a   20122a8 <rtems_rfs_inode_create+0xa8>   <== NOT EXECUTED
 2012268:	21 00 80 cb 	sethi  %hi(0x2032c00), %l0                     <== NOT EXECUTED
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))                 
  {                                                                   
    const char* type = "unknown";                                     
 201226c:	21 00 80 cb 	sethi  %hi(0x2032c00), %l0                     <== NOT EXECUTED
 2012270:	10 80 00 0f 	b  20122ac <rtems_rfs_inode_create+0xac>       <== NOT EXECUTED
 2012274:	a0 14 20 68 	or  %l0, 0x68, %l0	! 2032c68 <_CPU_Trap_slot_template+0xc30><== NOT EXECUTED
    int         c;                                                    
    if (RTEMS_RFS_S_ISDIR (mode))                                     
      type = "dir";                                                   
 2012278:	21 00 80 cb 	sethi  %hi(0x2032c00), %l0                     <== NOT EXECUTED
 201227c:	10 80 00 0c 	b  20122ac <rtems_rfs_inode_create+0xac>       <== NOT EXECUTED
 2012280:	a0 14 20 50 	or  %l0, 0x50, %l0	! 2032c50 <_CPU_Trap_slot_template+0xc18><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISCHR (mode))                                
      type = "char";                                                  
 2012284:	21 00 80 cb 	sethi  %hi(0x2032c00), %l0                     <== NOT EXECUTED
 2012288:	10 80 00 09 	b  20122ac <rtems_rfs_inode_create+0xac>       <== NOT EXECUTED
 201228c:	a0 14 20 58 	or  %l0, 0x58, %l0	! 2032c58 <_CPU_Trap_slot_template+0xc20><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISBLK (mode))                                
      type = "block";                                                 
 2012290:	21 00 80 ca 	sethi  %hi(0x2032800), %l0                     <== NOT EXECUTED
 2012294:	10 80 00 06 	b  20122ac <rtems_rfs_inode_create+0xac>       <== NOT EXECUTED
 2012298:	a0 14 22 50 	or  %l0, 0x250, %l0	! 2032a50 <_CPU_Trap_slot_template+0xa18><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISREG (mode))                                
      type = "file";                                                  
 201229c:	21 00 80 cb 	sethi  %hi(0x2032c00), %l0                     <== NOT EXECUTED
 20122a0:	10 80 00 03 	b  20122ac <rtems_rfs_inode_create+0xac>       <== NOT EXECUTED
 20122a4:	a0 14 20 60 	or  %l0, 0x60, %l0	! 2032c60 <_CPU_Trap_slot_template+0xc28><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISLNK (mode))                                
      type = "link";                                                  
 20122a8:	a0 14 20 70 	or  %l0, 0x70, %l0                             <== NOT EXECUTED
    printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
 20122ac:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 20122b0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 20122b4:	90 12 20 78 	or  %o0, 0x78, %o0                             <== NOT EXECUTED
 20122b8:	40 00 3f 33 	call  2021f84 <printf>                         <== NOT EXECUTED
 20122bc:	a4 10 00 1a 	mov  %i2, %l2                                  <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
 20122c0:	10 80 00 04 	b  20122d0 <rtems_rfs_inode_create+0xd0>       <== NOT EXECUTED
 20122c4:	aa 06 80 1b 	add  %i2, %i3, %l5                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
 20122c8:	40 00 3f 99 	call  202212c <putchar>                        <== NOT EXECUTED
 20122cc:	a4 04 a0 01 	inc  %l2                                       <== 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++)                                      
 20122d0:	80 a4 80 15 	cmp  %l2, %l5                                  <== NOT EXECUTED
 20122d4:	32 bf ff fd 	bne,a   20122c8 <rtems_rfs_inode_create+0xc8>  <== NOT EXECUTED
 20122d8:	d0 4c 80 00 	ldsb  [ %l2 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
 20122dc:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 20122e0:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 20122e4:	90 12 20 a8 	or  %o0, 0xa8, %o0                             <== NOT EXECUTED
 20122e8:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 20122ec:	40 00 3f 26 	call  2021f84 <printf>                         <== NOT EXECUTED
 20122f0:	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)                                    
 20122f4:	a4 0f 30 00 	and  %i4, -4096, %l2                           <== NOT EXECUTED
 20122f8:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
 20122fc:	80 a4 80 02 	cmp  %l2, %g2                                  
 2012300:	02 80 00 11 	be  2012344 <rtems_rfs_inode_create+0x144>     <== NEVER TAKEN
 2012304:	82 10 00 12 	mov  %l2, %g1                                  
 2012308:	80 a4 80 02 	cmp  %l2, %g2                                  
 201230c:	18 80 00 08 	bgu  201232c <rtems_rfs_inode_create+0x12c>    
 2012310:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
 2012314:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
 2012318:	80 a4 80 02 	cmp  %l2, %g2                                  
 201231c:	02 80 00 0a 	be  2012344 <rtems_rfs_inode_create+0x144>     <== NEVER TAKEN
 2012320:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
 2012324:	10 80 00 06 	b  201233c <rtems_rfs_inode_create+0x13c>      
 2012328:	80 a0 40 02 	cmp  %g1, %g2                                  
 201232c:	80 a4 80 02 	cmp  %l2, %g2                                  
 2012330:	02 80 00 05 	be  2012344 <rtems_rfs_inode_create+0x144>     
 2012334:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
 2012338:	80 a0 40 02 	cmp  %g1, %g2                                  
 201233c:	12 80 00 81 	bne  2012540 <rtems_rfs_inode_create+0x340>    <== NEVER TAKEN
 2012340:	a0 10 20 16 	mov  0x16, %l0                                 
      break;                                                          
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, parent, ino);                       
 2012344:	90 10 00 18 	mov  %i0, %o0                                  
 2012348:	92 10 00 19 	mov  %i1, %o1                                  
 201234c:	7f ff fe 2a 	call  2011bf4 <rtems_rfs_inode_alloc>          
 2012350:	94 10 00 11 	mov  %l1, %o2                                  
  if (rc > 0)                                                         
 2012354:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2012358:	34 80 00 7b 	bg,a   2012544 <rtems_rfs_inode_create+0x344>  
 201235c:	b0 10 00 10 	mov  %l0, %i0                                  
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, *ino, &inode, true);                 
 2012360:	d2 04 40 00 	ld  [ %l1 ], %o1                               
 2012364:	90 10 00 18 	mov  %i0, %o0                                  
 2012368:	94 07 bf d8 	add  %fp, -40, %o2                             
 201236c:	7f ff fe 5e 	call  2011ce4 <rtems_rfs_inode_open>           
 2012370:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 2012374:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2012378:	04 80 00 04 	ble  2012388 <rtems_rfs_inode_create+0x188>    <== ALWAYS TAKEN
 201237c:	90 07 bf d8 	add  %fp, -40, %o0                             
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
 2012380:	10 80 00 6c 	b  2012530 <rtems_rfs_inode_create+0x330>      <== NOT EXECUTED
 2012384:	d2 04 40 00 	ld  [ %l1 ], %o1                               <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);    
 2012388:	92 10 00 1d 	mov  %i5, %o1                                  
 201238c:	94 10 00 1c 	mov  %i4, %o2                                  
 2012390:	96 10 00 14 	mov  %l4, %o3                                  
 2012394:	7f ff ff 47 	call  20120b0 <rtems_rfs_inode_initialise>     
 2012398:	98 10 00 13 	mov  %l3, %o4                                  
  if (rc > 0)                                                         
 201239c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 20123a0:	04 80 00 07 	ble  20123bc <rtems_rfs_inode_create+0x1bc>    <== ALWAYS TAKEN
 20123a4:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
 20123a8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 20123ac:	7f ff fe c0 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 20123b0:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
 20123b4:	10 80 00 5f 	b  2012530 <rtems_rfs_inode_create+0x330>      <== NOT EXECUTED
 20123b8:	d2 04 40 00 	ld  [ %l1 ], %o1                               <== NOT EXECUTED
  /*                                                                  
   * Only handle the specifics of a directory. Let caller handle the others.
   *                                                                  
   * The inode delete will free the inode.                            
   */                                                                 
  if (RTEMS_RFS_S_ISDIR (mode))                                       
 20123bc:	80 a4 80 01 	cmp  %l2, %g1                                  
 20123c0:	12 80 00 17 	bne  201241c <rtems_rfs_inode_create+0x21c>    
 20123c4:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);          
 20123c8:	d8 04 40 00 	ld  [ %l1 ], %o4                               
 20123cc:	92 07 bf d8 	add  %fp, -40, %o1                             
 20123d0:	15 00 80 c0 	sethi  %hi(0x2030000), %o2                     
 20123d4:	96 10 20 01 	mov  1, %o3                                    
 20123d8:	40 00 27 05 	call  201bfec <rtems_rfs_dir_add_entry>        
 20123dc:	94 12 a3 30 	or  %o2, 0x330, %o2                            
    if (rc == 0)                                                      
 20123e0:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 20123e4:	12 80 00 0b 	bne  2012410 <rtems_rfs_inode_create+0x210>    <== NEVER TAKEN
 20123e8:	80 a4 20 00 	cmp  %l0, 0                                    
      rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);     
 20123ec:	90 10 00 18 	mov  %i0, %o0                                  
 20123f0:	92 07 bf d8 	add  %fp, -40, %o1                             
 20123f4:	15 00 80 c0 	sethi  %hi(0x2030000), %o2                     
 20123f8:	96 10 20 02 	mov  2, %o3                                    
 20123fc:	94 12 a3 38 	or  %o2, 0x338, %o2                            
 2012400:	40 00 26 fb 	call  201bfec <rtems_rfs_dir_add_entry>        
 2012404:	98 10 00 19 	mov  %i1, %o4                                  
 2012408:	a0 10 00 08 	mov  %o0, %l0                                  
    if (rc > 0)                                                       
 201240c:	80 a4 20 00 	cmp  %l0, 0                                    
 2012410:	14 80 00 0b 	bg  201243c <rtems_rfs_inode_create+0x23c>     <== NEVER TAKEN
 2012414:	90 10 00 18 	mov  %i0, %o0                                  
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
 2012418:	90 10 00 18 	mov  %i0, %o0                                  
 201241c:	92 10 00 19 	mov  %i1, %o1                                  
 2012420:	94 07 bf b0 	add  %fp, -80, %o2                             
 2012424:	7f ff fe 30 	call  2011ce4 <rtems_rfs_inode_open>           
 2012428:	96 10 20 01 	mov  1, %o3                                    
 201242c:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
 2012430:	80 a4 20 00 	cmp  %l0, 0                                    
 2012434:	04 80 00 04 	ble  2012444 <rtems_rfs_inode_create+0x244>    <== ALWAYS TAKEN
 2012438:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
 201243c:	10 80 00 30 	b  20124fc <rtems_rfs_inode_create+0x2fc>      <== NOT EXECUTED
 2012440:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
 2012444:	d8 04 40 00 	ld  [ %l1 ], %o4                               
 2012448:	92 07 bf b0 	add  %fp, -80, %o1                             
 201244c:	94 10 00 1a 	mov  %i2, %o2                                  
 2012450:	40 00 26 e7 	call  201bfec <rtems_rfs_dir_add_entry>        
 2012454:	96 10 00 1b 	mov  %i3, %o3                                  
  if (rc > 0)                                                         
 2012458:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201245c:	04 80 00 0b 	ble  2012488 <rtems_rfs_inode_create+0x288>    <== ALWAYS TAKEN
 2012460:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
 2012464:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 2012468:	7f ff fe b4 	call  2011f38 <rtems_rfs_inode_delete>         <== NOT EXECUTED
 201246c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
 2012470:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 2012474:	7f ff fe 8e 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 2012478:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &parent_inode);                        
 201247c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2012480:	10 80 00 23 	b  201250c <rtems_rfs_inode_create+0x30c>      <== NOT EXECUTED
 2012484:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * If the node is a directory update the parent link count as the   
   * new directory has the '..' link that points to the parent.       
   */                                                                 
  if (RTEMS_RFS_S_ISDIR (mode))                                       
 2012488:	80 a4 80 01 	cmp  %l2, %g1                                  
 201248c:	12 80 00 15 	bne  20124e0 <rtems_rfs_inode_create+0x2e0>    
 2012490:	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);                  
 2012494:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         
  if (links == 0xffff)                                                
 2012498:	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);                  
 201249c:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
 20124a0:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
 20124a4:	85 28 a0 08 	sll  %g2, 8, %g2                               
 20124a8:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (links == 0xffff)                                                
 20124ac:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
 20124b0:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
    links = 0;                                                        
 20124b4:	86 39 00 03 	xnor  %g4, %g3, %g3                            
 20124b8:	80 a0 00 03 	cmp  %g0, %g3                                  
 20124bc:	86 60 20 00 	subx  %g0, 0, %g3                              
 20124c0:	84 08 80 03 	and  %g2, %g3, %g2                             
    rtems_rfs_inode_set_links (&parent_inode,                         
 20124c4:	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);                  
 20124c8:	87 30 a0 08 	srl  %g2, 8, %g3                               
 20124cc:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
 20124d0:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         
 20124d4:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 20124d8:	82 10 20 01 	mov  1, %g1                                    
 20124dc:	c2 2f bf c0 	stb  %g1, [ %fp + -64 ]                        
                               rtems_rfs_inode_get_links (&parent_inode) + 1);
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
 20124e0:	7f ff fe 73 	call  2011eac <rtems_rfs_inode_close>          
 20124e4:	90 10 00 18 	mov  %i0, %o0                                  
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
 20124e8:	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);                     
 20124ec:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
 20124f0:	80 a4 20 00 	cmp  %l0, 0                                    
 20124f4:	04 80 00 09 	ble  2012518 <rtems_rfs_inode_create+0x318>    <== ALWAYS TAKEN
 20124f8:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
 20124fc:	7f ff fe 8f 	call  2011f38 <rtems_rfs_inode_delete>         <== NOT EXECUTED
 2012500:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
 2012504:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2012508:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 201250c:	7f ff fe 68 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 2012510:	b0 10 00 10 	mov  %l0, %i0                                  <== NOT EXECUTED
 2012514:	30 80 00 0c 	b,a   2012544 <rtems_rfs_inode_create+0x344>   <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 2012518:	7f ff fe 65 	call  2011eac <rtems_rfs_inode_close>          
 201251c:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
 2012520:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 2012524:	24 80 00 07 	ble,a   2012540 <rtems_rfs_inode_create+0x340> <== ALWAYS TAKEN
 2012528:	a0 10 20 00 	clr  %l0                                       
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
 201252c:	d2 04 40 00 	ld  [ %l1 ], %o1                               <== NOT EXECUTED
 2012530:	7f ff fd bb 	call  2011c1c <rtems_rfs_inode_free>           <== NOT EXECUTED
 2012534:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2012538:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201253c:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
 2012540:	b0 10 00 10 	mov  %l0, %i0                                  
 2012544:	81 c7 e0 08 	ret                                            
 2012548:	81 e8 00 00 	restore                                        
                                                                      

02011f38 <rtems_rfs_inode_delete>: } int rtems_rfs_inode_delete (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
 2011f38:	9d e3 bf 50 	save  %sp, -176, %sp                           
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))                 
 2011f3c:	90 10 20 00 	clr  %o0                                       
 2011f40:	40 00 05 f2 	call  2013708 <rtems_rfs_trace>                
 2011f44:	13 00 20 00 	sethi  %hi(0x800000), %o1                      
 2011f48:	80 8a 20 ff 	btst  0xff, %o0                                
 2011f4c:	22 80 00 0f 	be,a   2011f88 <rtems_rfs_inode_delete+0x50>   <== ALWAYS TAKEN
 2011f50:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",    
 2011f54:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
 2011f58:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2011f5c:	02 80 00 05 	be  2011f70 <rtems_rfs_inode_delete+0x38>      <== NOT EXECUTED
 2011f60:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 2011f64:	15 00 80 ca 	sethi  %hi(0x2032800), %o2                     <== NOT EXECUTED
 2011f68:	10 80 00 04 	b  2011f78 <rtems_rfs_inode_delete+0x40>       <== NOT EXECUTED
 2011f6c:	94 12 a3 28 	or  %o2, 0x328, %o2	! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
 2011f70:	15 00 80 c3 	sethi  %hi(0x2030c00), %o2                     <== NOT EXECUTED
 2011f74:	94 12 a0 10 	or  %o2, 0x10, %o2	! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
 2011f78:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 2011f7c:	40 00 40 02 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011f80:	90 12 20 20 	or  %o0, 0x20, %o0	! 2032c20 <_CPU_Trap_slot_template+0xbe8><== NOT EXECUTED
           rtems_rfs_inode_ino (handle),                              
           rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");        
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
 2011f84:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         <== NOT EXECUTED
 2011f88:	80 a0 a0 00 	cmp  %g2, 0                                    
 2011f8c:	02 80 00 1e 	be  2012004 <rtems_rfs_inode_delete+0xcc>      <== NEVER TAKEN
 2011f90:	90 10 20 00 	clr  %o0                                       
    rtems_rfs_block_map map;                                          
                                                                      
    /*                                                                
     * Free the ino number.                                           
     */                                                               
    rc = rtems_rfs_inode_free (fs, handle->ino);                      
 2011f94:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
 2011f98:	7f ff ff 21 	call  2011c1c <rtems_rfs_inode_free>           
 2011f9c:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc > 0)                                                       
 2011fa0:	80 a2 20 00 	cmp  %o0, 0                                    
 2011fa4:	14 80 00 18 	bg  2012004 <rtems_rfs_inode_delete+0xcc>      <== NEVER TAKEN
 2011fa8:	92 10 00 19 	mov  %i1, %o1                                  
      return rc;                                                      
                                                                      
    /*                                                                
     * Free the blocks the inode may have attached.                   
     */                                                               
    rc = rtems_rfs_block_map_open (fs, handle, &map);                 
 2011fac:	90 10 00 18 	mov  %i0, %o0                                  
 2011fb0:	40 00 21 25 	call  201a444 <rtems_rfs_block_map_open>       
 2011fb4:	94 07 bf b0 	add  %fp, -80, %o2                             
    if (rc == 0)                                                      
 2011fb8:	80 a2 20 00 	cmp  %o0, 0                                    
 2011fbc:	12 80 00 12 	bne  2012004 <rtems_rfs_inode_delete+0xcc>     <== NEVER TAKEN
 2011fc0:	92 07 bf b0 	add  %fp, -80, %o1                             
    {                                                                 
      int rrc;                                                        
      rrc = rtems_rfs_block_map_free_all (fs, &map);                  
 2011fc4:	40 00 24 35 	call  201b098 <rtems_rfs_block_map_free_all>   
 2011fc8:	90 10 00 18 	mov  %i0, %o0                                  
      rc = rtems_rfs_block_map_close (fs, &map);                      
 2011fcc:	92 07 bf b0 	add  %fp, -80, %o1                             
 2011fd0:	40 00 21 7e 	call  201a5c8 <rtems_rfs_block_map_close>      
 2011fd4:	90 10 00 18 	mov  %i0, %o0                                  
      if (rc > 0)                                                     
        rrc = rc;                                                     
      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);              
 2011fd8:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
 2011fdc:	92 10 20 ff 	mov  0xff, %o1                                 
 2011fe0:	40 00 3f 6b 	call  2021d8c <memset>                         
 2011fe4:	94 10 20 38 	mov  0x38, %o2                                 
      rtems_rfs_buffer_mark_dirty (&handle->buffer);                  
 2011fe8:	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);     
 2011fec:	90 10 00 18 	mov  %i0, %o0                                  
      rrc = rtems_rfs_block_map_free_all (fs, &map);                  
      rc = rtems_rfs_block_map_close (fs, &map);                      
      if (rc > 0)                                                     
        rrc = rc;                                                     
      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);              
      rtems_rfs_buffer_mark_dirty (&handle->buffer);                  
 2011ff0:	c2 2e 60 10 	stb  %g1, [ %i1 + 0x10 ]                       
      /*                                                              
       * 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);     
 2011ff4:	40 00 24 8d 	call  201b228 <rtems_rfs_buffer_handle_release>
 2011ff8:	92 06 60 10 	add  %i1, 0x10, %o1                            
      handle->loads = 0;                                              
 2011ffc:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
      handle->node = NULL;                                            
 2012000:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
    }                                                                 
  }                                                                   
  return rc;                                                          
}                                                                     
 2012004:	81 c7 e0 08 	ret                                            
 2012008:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

020125cc <rtems_rfs_inode_get_block>: * @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]);
 20125cc:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
 20125d0:	92 02 60 06 	add  %o1, 6, %o1                               <== NOT EXECUTED
 20125d4:	85 2a 60 02 	sll  %o1, 2, %g2                               <== NOT EXECUTED
 20125d8:	84 00 40 02 	add  %g1, %g2, %g2                             <== NOT EXECUTED
 20125dc:	82 00 a0 04 	add  %g2, 4, %g1                               <== NOT EXECUTED
 20125e0:	d0 08 a0 04 	ldub  [ %g2 + 4 ], %o0                         <== NOT EXECUTED
 20125e4:	c4 08 a0 05 	ldub  [ %g2 + 5 ], %g2                         <== NOT EXECUTED
 20125e8:	91 2a 20 18 	sll  %o0, 0x18, %o0                            <== NOT EXECUTED
 20125ec:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
 20125f0:	90 12 00 02 	or  %o0, %g2, %o0                              <== NOT EXECUTED
 20125f4:	c4 08 60 03 	ldub  [ %g1 + 3 ], %g2                         <== NOT EXECUTED
 20125f8:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
 20125fc:	90 12 00 02 	or  %o0, %g2, %o0                              <== NOT EXECUTED
 2012600:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
}                                                                     
 2012604:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2012608:	90 12 00 01 	or  %o0, %g1, %o0                              <== NOT EXECUTED
                                                                      

02011c30 <rtems_rfs_inode_load>: } int rtems_rfs_inode_load (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
 2011c30:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))                   
 2011c34:	90 10 20 00 	clr  %o0                                       
 2011c38:	40 00 06 b4 	call  2013708 <rtems_rfs_trace>                
 2011c3c:	13 00 04 00 	sethi  %hi(0x100000), %o1                      
 2011c40:	80 8a 20 ff 	btst  0xff, %o0                                
 2011c44:	02 80 00 0f 	be  2011c80 <rtems_rfs_inode_load+0x50>        <== ALWAYS TAKEN
 2011c48:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
 2011c4c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 2011c50:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2011c54:	02 80 00 05 	be  2011c68 <rtems_rfs_inode_load+0x38>        <== NOT EXECUTED
 2011c58:	d4 06 60 24 	ld  [ %i1 + 0x24 ], %o2                        <== NOT EXECUTED
 2011c5c:	17 00 80 ca 	sethi  %hi(0x2032800), %o3                     <== NOT EXECUTED
 2011c60:	10 80 00 04 	b  2011c70 <rtems_rfs_inode_load+0x40>         <== NOT EXECUTED
 2011c64:	96 12 e3 28 	or  %o3, 0x328, %o3	! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
 2011c68:	17 00 80 c3 	sethi  %hi(0x2030c00), %o3                     <== NOT EXECUTED
 2011c6c:	96 12 e0 10 	or  %o3, 0x10, %o3	! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
 2011c70:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011c74:	40 00 40 c4 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011c78:	90 12 23 30 	or  %o0, 0x330, %o0	! 2032b30 <_CPU_Trap_slot_template+0xaf8><== NOT EXECUTED
                                                                      
  /*                                                                  
   * An inode does not move so once loaded no need to do again.       
   */                                                                 
                                                                      
  if (!rtems_rfs_inode_is_loaded (handle))                            
 2011c7c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
 2011c80:	80 a0 60 00 	cmp  %g1, 0                                    
 2011c84:	32 80 00 13 	bne,a   2011cd0 <rtems_rfs_inode_load+0xa0>    
 2011c88:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
  {                                                                   
    int rc;                                                           
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,         
 2011c8c:	d4 06 60 1c 	ld  [ %i1 + 0x1c ], %o2                        
 2011c90:	90 10 00 18 	mov  %i0, %o0                                  
 2011c94:	92 06 60 10 	add  %i1, 0x10, %o1                            
 2011c98:	40 00 25 d8 	call  201b3f8 <rtems_rfs_buffer_handle_request>
 2011c9c:	96 10 20 01 	mov  1, %o3                                    
                                          handle->block, true);       
    if (rc > 0)                                                       
 2011ca0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2011ca4:	14 80 00 0e 	bg  2011cdc <rtems_rfs_inode_load+0xac>        <== NEVER TAKEN
 2011ca8:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
 2011cac:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2                        
    handle->node += handle->offset;                                   
 2011cb0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
 2011cb4:	c4 00 a0 1c 	ld  [ %g2 + 0x1c ], %g2                        
 2011cb8:	87 28 60 03 	sll  %g1, 3, %g3                               
 2011cbc:	83 28 60 06 	sll  %g1, 6, %g1                               
 2011cc0:	82 20 40 03 	sub  %g1, %g3, %g1                             
 2011cc4:	82 00 80 01 	add  %g2, %g1, %g1                             
 2011cc8:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
  }                                                                   
                                                                      
  handle->loads++;                                                    
 2011ccc:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
                                                                      
  return 0;                                                           
 2011cd0:	b0 10 20 00 	clr  %i0                                       
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
    handle->node += handle->offset;                                   
  }                                                                   
                                                                      
  handle->loads++;                                                    
 2011cd4:	82 00 60 01 	inc  %g1                                       
 2011cd8:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
                                                                      
  return 0;                                                           
}                                                                     
 2011cdc:	81 c7 e0 08 	ret                                            
 2011ce0:	81 e8 00 00 	restore                                        
                                                                      

02011ce4 <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) {
 2011ce4:	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))                   
 2011ce8:	90 10 20 00 	clr  %o0                                       
 2011cec:	40 00 06 87 	call  2013708 <rtems_rfs_trace>                
 2011cf0:	13 00 01 00 	sethi  %hi(0x40000), %o1                       
 2011cf4:	80 8a 20 ff 	btst  0xff, %o0                                
 2011cf8:	02 80 00 07 	be  2011d14 <rtems_rfs_inode_open+0x30>        <== ALWAYS TAKEN
 2011cfc:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);        
 2011d00:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011d04:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 2011d08:	40 00 40 9f 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011d0c:	90 12 23 68 	or  %o0, 0x368, %o0                            <== NOT EXECUTED
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
 2011d10:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
 2011d14:	02 80 00 28 	be  2011db4 <rtems_rfs_inode_open+0xd0>        <== NEVER TAKEN
 2011d18:	82 10 20 16 	mov  0x16, %g1                                 
    return EINVAL;                                                    
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
 2011d1c:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
 2011d20:	ba 06 7f ff 	add  %i1, -1, %i5                              
 2011d24:	80 a7 40 02 	cmp  %i5, %g2                                  
 2011d28:	18 80 00 23 	bgu  2011db4 <rtems_rfs_inode_open+0xd0>       <== NEVER TAKEN
 2011d2c:	90 10 00 1d 	mov  %i5, %o0                                  
    return EINVAL;                                                    
                                                                      
  handle->ino = ino;                                                  
 2011d30:	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;                                    
 2011d34:	f2 06 20 2c 	ld  [ %i0 + 0x2c ], %i1                        
  gino  = gino % fs->group_inodes;                                    
 2011d38:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))          
    return EINVAL;                                                    
                                                                      
  handle->ino = ino;                                                  
  handle->node = NULL;                                                
 2011d3c:	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;                                    
 2011d40:	40 00 71 12 	call  202e188 <.urem>                          
 2011d44:	c0 26 a0 24 	clr  [ %i2 + 0x24 ]                            
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
 2011d48:	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;                                    
 2011d4c:	a0 10 00 08 	mov  %o0, %l0                                  
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
 2011d50:	40 00 71 0e 	call  202e188 <.urem>                          
 2011d54:	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;                                    
 2011d58:	92 10 00 19 	mov  %i1, %o1                                  
  gino  = gino % fs->group_inodes;                                    
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
 2011d5c:	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;                                    
 2011d60:	7f ff c2 47 	call  200267c <.udiv>                          
 2011d64:	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); 
 2011d68:	c4 06 20 20 	ld  [ %i0 + 0x20 ], %g2                        
 2011d6c:	87 2a 20 04 	sll  %o0, 4, %g3                               
 2011d70:	83 2a 20 06 	sll  %o0, 6, %g1                               
 2011d74:	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;
 2011d78:	fa 00 80 01 	ld  [ %g2 + %g1 ], %i5                         
 2011d7c:	90 10 00 10 	mov  %l0, %o0                                  
 2011d80:	ba 07 60 02 	add  %i5, 2, %i5                               
 2011d84:	7f ff c2 3e 	call  200267c <.udiv>                          
 2011d88:	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;                                              
 2011d8c:	c0 2e a0 10 	clrb  [ %i2 + 0x10 ]                           
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
 2011d90:	90 07 40 08 	add  %i5, %o0, %o0                             
  handle->bnum  = 0;                                                  
 2011d94:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
 2011d98:	d0 26 a0 1c 	st  %o0, [ %i2 + 0x1c ]                        
  handle->buffer = NULL;                                              
 2011d9c:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
 2011da0:	80 a6 e0 00 	cmp  %i3, 0                                    
 2011da4:	02 80 00 04 	be  2011db4 <rtems_rfs_inode_open+0xd0>        <== NEVER TAKEN
 2011da8:	82 10 20 00 	clr  %g1                                       
    rc = rtems_rfs_inode_load (fs, handle);                           
 2011dac:	7f ff ff a1 	call  2011c30 <rtems_rfs_inode_load>           
 2011db0:	93 e8 00 1a 	restore  %g0, %i2, %o1                         
  return rc;                                                          
}                                                                     
 2011db4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2011db8:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
                                                                      

0201260c <rtems_rfs_inode_set_block>: * @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);
 201260c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
 2012610:	92 02 60 06 	add  %o1, 6, %o1                               <== NOT EXECUTED
 2012614:	93 2a 60 02 	sll  %o1, 2, %o1                               <== NOT EXECUTED
 2012618:	82 00 40 09 	add  %g1, %o1, %g1                             <== NOT EXECUTED
 201261c:	85 32 a0 18 	srl  %o2, 0x18, %g2                            <== NOT EXECUTED
 2012620:	c4 28 60 04 	stb  %g2, [ %g1 + 4 ]                          <== NOT EXECUTED
 2012624:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
 2012628:	85 32 a0 10 	srl  %o2, 0x10, %g2                            <== NOT EXECUTED
 201262c:	82 00 40 09 	add  %g1, %o1, %g1                             <== NOT EXECUTED
 2012630:	c4 28 60 05 	stb  %g2, [ %g1 + 5 ]                          <== NOT EXECUTED
 2012634:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
 2012638:	85 32 a0 08 	srl  %o2, 8, %g2                               <== NOT EXECUTED
 201263c:	82 00 40 09 	add  %g1, %o1, %g1                             <== NOT EXECUTED
 2012640:	c4 28 60 06 	stb  %g2, [ %g1 + 6 ]                          <== NOT EXECUTED
 2012644:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
 2012648:	92 00 40 09 	add  %g1, %o1, %o1                             <== NOT EXECUTED
 201264c:	d4 2a 60 07 	stb  %o2, [ %o1 + 7 ]                          <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 2012650:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2012654:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2012658:	c2 2a 20 10 	stb  %g1, [ %o0 + 0x10 ]                       <== NOT EXECUTED
                                                                      

0201200c <rtems_rfs_inode_time_stamp_now>: int rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle, bool atime, bool mtime) {
 201200c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
 2012010:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
                                                                      
int                                                                   
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,       
                                bool                    atime,        
                                bool                    mtime)        
{                                                                     
 2012014:	ba 10 00 18 	mov  %i0, %i5                                  
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
 2012018:	80 a0 60 00 	cmp  %g1, 0                                    
 201201c:	02 80 00 23 	be  20120a8 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
 2012020:	b0 10 20 06 	mov  6, %i0                                    
    return ENXIO;                                                     
  now = time (NULL);                                                  
 2012024:	40 00 4f f4 	call  2025ff4 <time>                           
 2012028:	90 10 20 00 	clr  %o0                                       
  if (atime)                                                          
 201202c:	80 a6 60 00 	cmp  %i1, 0                                    
 2012030:	02 80 00 0f 	be  201206c <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
 2012034:	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);                  
 2012038:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 201203c:	85 32 20 18 	srl  %o0, 0x18, %g2                            
 2012040:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       
 2012044:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2012048:	85 32 20 10 	srl  %o0, 0x10, %g2                            
 201204c:	c4 28 60 11 	stb  %g2, [ %g1 + 0x11 ]                       
 2012050:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2012054:	85 32 20 08 	srl  %o0, 8, %g2                               
 2012058:	c4 28 60 12 	stb  %g2, [ %g1 + 0x12 ]                       
 201205c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2012060:	d0 28 60 13 	stb  %o0, [ %g1 + 0x13 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 2012064:	82 10 20 01 	mov  1, %g1                                    
 2012068:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    rtems_rfs_inode_set_atime (handle, now);                          
  if (mtime)                                                          
 201206c:	02 80 00 0f 	be  20120a8 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
 2012070:	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);                  
 2012074:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2012078:	85 32 20 18 	srl  %o0, 0x18, %g2                            
 201207c:	c4 28 60 14 	stb  %g2, [ %g1 + 0x14 ]                       
 2012080:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2012084:	85 32 20 10 	srl  %o0, 0x10, %g2                            
 2012088:	c4 28 60 15 	stb  %g2, [ %g1 + 0x15 ]                       
 201208c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2012090:	85 32 20 08 	srl  %o0, 8, %g2                               
 2012094:	c4 28 60 16 	stb  %g2, [ %g1 + 0x16 ]                       
 2012098:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 201209c:	d0 28 60 17 	stb  %o0, [ %g1 + 0x17 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 20120a0:	82 10 20 01 	mov  1, %g1                                    
 20120a4:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    rtems_rfs_inode_set_mtime (handle, now);                          
  return 0;                                                           
}                                                                     
 20120a8:	81 c7 e0 08 	ret                                            
 20120ac:	81 e8 00 00 	restore                                        
                                                                      

02011dbc <rtems_rfs_inode_unload>: int rtems_rfs_inode_unload (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle, bool update_ctime) {
 2011dbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))                 
 2011dc0:	90 10 20 00 	clr  %o0                                       
 2011dc4:	40 00 06 51 	call  2013708 <rtems_rfs_trace>                
 2011dc8:	13 00 08 00 	sethi  %hi(0x200000), %o1                      
 2011dcc:	80 8a 20 ff 	btst  0xff, %o0                                
 2011dd0:	02 80 00 0f 	be  2011e0c <rtems_rfs_inode_unload+0x50>      <== ALWAYS TAKEN
 2011dd4:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
 2011dd8:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
 2011ddc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2011de0:	02 80 00 05 	be  2011df4 <rtems_rfs_inode_unload+0x38>      <== NOT EXECUTED
 2011de4:	d4 06 60 24 	ld  [ %i1 + 0x24 ], %o2                        <== NOT EXECUTED
 2011de8:	17 00 80 ca 	sethi  %hi(0x2032800), %o3                     <== NOT EXECUTED
 2011dec:	10 80 00 04 	b  2011dfc <rtems_rfs_inode_unload+0x40>       <== NOT EXECUTED
 2011df0:	96 12 e3 28 	or  %o3, 0x328, %o3	! 2032b28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
 2011df4:	17 00 80 c3 	sethi  %hi(0x2030c00), %o3                     <== NOT EXECUTED
 2011df8:	96 12 e0 10 	or  %o3, 0x10, %o3	! 2030c10 <__FUNCTION__.7127+0x538><== NOT EXECUTED
 2011dfc:	11 00 80 ca 	sethi  %hi(0x2032800), %o0                     <== NOT EXECUTED
 2011e00:	40 00 40 61 	call  2021f84 <printf>                         <== NOT EXECUTED
 2011e04:	90 12 23 90 	or  %o0, 0x390, %o0	! 2032b90 <_CPU_Trap_slot_template+0xb58><== NOT EXECUTED
            handle->ino, handle->loads,                               
            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");       
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
 2011e08:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
 2011e0c:	80 a0 60 00 	cmp  %g1, 0                                    
 2011e10:	32 80 00 04 	bne,a   2011e20 <rtems_rfs_inode_unload+0x64>  
 2011e14:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
int                                                                   
rtems_rfs_inode_unload (rtems_rfs_file_system*  fs,                   
                        rtems_rfs_inode_handle* handle,               
                        bool                    update_ctime)         
{                                                                     
  int rc = 0;                                                         
 2011e18:	10 80 00 23 	b  2011ea4 <rtems_rfs_inode_unload+0xe8>       
 2011e1c:	90 10 20 00 	clr  %o0                                       
            handle->ino, handle->loads,                               
            rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");       
                                                                      
  if (rtems_rfs_inode_is_loaded (handle))                             
  {                                                                   
    if (handle->loads == 0)                                           
 2011e20:	80 a0 a0 00 	cmp  %g2, 0                                    
 2011e24:	02 80 00 20 	be  2011ea4 <rtems_rfs_inode_unload+0xe8>      <== NEVER TAKEN
 2011e28:	90 10 20 05 	mov  5, %o0                                    
      return EIO;                                                     
                                                                      
    handle->loads--;                                                  
 2011e2c:	82 00 bf ff 	add  %g2, -1, %g1                              
                                                                      
    if (handle->loads == 0)                                           
 2011e30:	80 a0 60 00 	cmp  %g1, 0                                    
 2011e34:	12 bf ff f9 	bne  2011e18 <rtems_rfs_inode_unload+0x5c>     
 2011e38:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    {                                                                 
      /*                                                              
       * If the buffer is dirty it will be release. Also set the ctime.
       */                                                             
      if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)   
 2011e3c:	c2 0e 60 10 	ldub  [ %i1 + 0x10 ], %g1                      
 2011e40:	80 a0 60 00 	cmp  %g1, 0                                    
 2011e44:	02 80 00 15 	be  2011e98 <rtems_rfs_inode_unload+0xdc>      
 2011e48:	90 10 00 18 	mov  %i0, %o0                                  
 2011e4c:	80 a6 a0 00 	cmp  %i2, 0                                    
 2011e50:	02 80 00 12 	be  2011e98 <rtems_rfs_inode_unload+0xdc>      <== NEVER TAKEN
 2011e54:	01 00 00 00 	nop                                            
        rtems_rfs_inode_set_ctime (handle, time (NULL));              
 2011e58:	40 00 50 67 	call  2025ff4 <time>                           
 2011e5c:	90 10 20 00 	clr  %o0	! 0 <PROM_START>                      
 */                                                                   
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);                  
 2011e60:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 2011e64:	87 32 20 18 	srl  %o0, 0x18, %g3                            
 2011e68:	c6 28 a0 18 	stb  %g3, [ %g2 + 0x18 ]                       
 2011e6c:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 2011e70:	87 32 20 10 	srl  %o0, 0x10, %g3                            
 2011e74:	c6 28 a0 19 	stb  %g3, [ %g2 + 0x19 ]                       
 2011e78:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
 2011e7c:	87 32 20 08 	srl  %o0, 8, %g3                               
 2011e80:	c6 28 a0 1a 	stb  %g3, [ %g2 + 0x1a ]                       
 2011e84:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 2011e88:	82 10 20 01 	mov  1, %g1                                    
 */                                                                   
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);                  
 2011e8c:	d0 28 a0 1b 	stb  %o0, [ %g2 + 0x1b ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 2011e90:	c2 2e 60 10 	stb  %g1, [ %i1 + 0x10 ]                       
      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);     
 2011e94:	90 10 00 18 	mov  %i0, %o0                                  
 2011e98:	40 00 24 e4 	call  201b228 <rtems_rfs_buffer_handle_release>
 2011e9c:	92 06 60 10 	add  %i1, 0x10, %o1                            
      handle->node = NULL;                                            
 2011ea0:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
 2011ea4:	81 c7 e0 08 	ret                                            
 2011ea8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0201e528 <rtems_rfs_link>: const char* name, int length, rtems_rfs_ino parent, rtems_rfs_ino target, bool link_dir) {
 201e528:	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))                         
 201e52c:	90 10 20 00 	clr  %o0                                       
 201e530:	7f ff d4 76 	call  2013708 <rtems_rfs_trace>                
 201e534:	13 00 40 00 	sethi  %hi(0x1000000), %o1                     
 201e538:	80 8a 20 ff 	btst  0xff, %o0                                
 201e53c:	02 80 00 13 	be  201e588 <rtems_rfs_link+0x60>              <== ALWAYS TAKEN
 201e540:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);      
 201e544:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e548:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201e54c:	90 12 20 e0 	or  %o0, 0xe0, %o0                             <== NOT EXECUTED
 201e550:	40 00 0e 8d 	call  2021f84 <printf>                         <== NOT EXECUTED
 201e554:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
 201e558:	10 80 00 05 	b  201e56c <rtems_rfs_link+0x44>               <== NOT EXECUTED
 201e55c:	80 a4 00 1a 	cmp  %l0, %i2                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
 201e560:	40 00 0e f3 	call  202212c <putchar>                        <== NOT EXECUTED
 201e564:	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++)                                      
 201e568:	80 a4 00 1a 	cmp  %l0, %i2                                  <== NOT EXECUTED
 201e56c:	26 bf ff fd 	bl,a   201e560 <rtems_rfs_link+0x38>           <== NOT EXECUTED
 201e570:	d0 4e 40 10 	ldsb  [ %i1 + %l0 ], %o0                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
 201e574:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e578:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 201e57c:	40 00 0e 82 	call  2021f84 <printf>                         <== NOT EXECUTED
 201e580:	90 12 21 08 	or  %o0, 0x108, %o0                            <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
 201e584:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201e588:	92 10 00 1c 	mov  %i4, %o1                                  
 201e58c:	94 07 bf d8 	add  %fp, -40, %o2                             
 201e590:	7f ff cd d5 	call  2011ce4 <rtems_rfs_inode_open>           
 201e594:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201e598:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201e59c:	12 80 00 49 	bne  201e6c0 <rtems_rfs_link+0x198>            <== NEVER TAKEN
 201e5a0:	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)))
 201e5a4:	12 80 00 10 	bne  201e5e4 <rtems_rfs_link+0xbc>             <== NEVER TAKEN
 201e5a8:	90 10 00 18 	mov  %i0, %o0                                  
 * @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);                    
 201e5ac:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 201e5b0:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
 201e5b4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 201e5b8:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201e5bc:	84 08 80 01 	and  %g2, %g1, %g2                             
 201e5c0:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 201e5c4:	80 a0 80 01 	cmp  %g2, %g1                                  
 201e5c8:	12 80 00 08 	bne  201e5e8 <rtems_rfs_link+0xc0>             <== ALWAYS TAKEN
 201e5cc:	92 10 00 1b 	mov  %i3, %o1                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
 201e5d0:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 201e5d4:	7f ff ce 36 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201e5d8:	a0 10 20 86 	mov  0x86, %l0                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
                                                                      
  return rc;                                                          
}                                                                     
 201e5dc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201e5e0:	91 e8 00 10 	restore  %g0, %l0, %o0                         <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return ENOTSUP;                                                   
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
 201e5e4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201e5e8:	94 07 bf b0 	add  %fp, -80, %o2                             
 201e5ec:	7f ff cd be 	call  2011ce4 <rtems_rfs_inode_open>           
 201e5f0:	96 10 20 01 	mov  1, %o3                                    
 201e5f4:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc)                                                             
 201e5f8:	80 a4 20 00 	cmp  %l0, 0                                    
 201e5fc:	02 80 00 04 	be  201e60c <rtems_rfs_link+0xe4>              <== ALWAYS TAKEN
 201e600:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
    rtems_rfs_inode_close (fs, &target_inode);                        
 201e604:	10 80 00 0f 	b  201e640 <rtems_rfs_link+0x118>              <== NOT EXECUTED
 201e608:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
 201e60c:	92 07 bf b0 	add  %fp, -80, %o1                             
 201e610:	94 10 00 19 	mov  %i1, %o2                                  
 201e614:	96 10 00 1a 	mov  %i2, %o3                                  
 201e618:	7f ff f6 75 	call  201bfec <rtems_rfs_dir_add_entry>        
 201e61c:	98 10 00 1c 	mov  %i4, %o4                                  
  if (rc > 0)                                                         
 201e620:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201e624:	04 80 00 0a 	ble  201e64c <rtems_rfs_link+0x124>            <== ALWAYS TAKEN
 201e628:	92 07 bf b0 	add  %fp, -80, %o1                             
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
 201e62c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201e630:	7f ff ce 1f 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201e634:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
 201e638:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201e63c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 201e640:	7f ff ce 1b 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201e644:	b0 10 00 10 	mov  %l0, %i0                                  <== NOT EXECUTED
 201e648:	30 80 00 1f 	b,a   201e6c4 <rtems_rfs_link+0x19c>           <== NOT EXECUTED
    return rc;                                                        
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode) + 1;              
 201e64c:	7f ff ff a8 	call  201e4ec <rtems_rfs_inode_get_links>      
 201e650:	90 07 bf d8 	add  %fp, -40, %o0                             
 * @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);                  
 201e654:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 201e658:	90 02 20 01 	inc  %o0                                       
 201e65c:	85 32 20 08 	srl  %o0, 8, %g2                               
 201e660:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
 201e664:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  rtems_rfs_inode_set_links (&target_inode, links);                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
 201e668:	92 10 20 01 	mov  1, %o1                                    
 201e66c:	d0 28 60 01 	stb  %o0, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201e670:	82 10 20 01 	mov  1, %g1                                    
 201e674:	90 07 bf b0 	add  %fp, -80, %o0                             
 201e678:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
 201e67c:	7f ff ce 64 	call  201200c <rtems_rfs_inode_time_stamp_now> 
 201e680:	94 10 20 01 	mov  1, %o2                                    
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
 201e684:	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);    
 201e688:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
 201e68c:	80 a4 20 00 	cmp  %l0, 0                                    
 201e690:	14 bf ff e8 	bg  201e630 <rtems_rfs_link+0x108>             <== NEVER TAKEN
 201e694:	90 10 00 18 	mov  %i0, %o0                                  
    rtems_rfs_inode_close (fs, &parent_inode);                        
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
 201e698:	7f ff ce 05 	call  2011eac <rtems_rfs_inode_close>          
 201e69c:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
 201e6a0:	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);                     
 201e6a4:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
 201e6a8:	80 a4 20 00 	cmp  %l0, 0                                    
 201e6ac:	14 bf ff e5 	bg  201e640 <rtems_rfs_link+0x118>             <== NEVER TAKEN
 201e6b0:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
 201e6b4:	7f ff cd fe 	call  2011eac <rtems_rfs_inode_close>          
 201e6b8:	01 00 00 00 	nop                                            
 201e6bc:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
  return rc;                                                          
}                                                                     
 201e6c0:	b0 10 00 10 	mov  %l0, %i0                                  
 201e6c4:	81 c7 e0 08 	ret                                            
 201e6c8:	81 e8 00 00 	restore                                        
                                                                      

0201eea4 <rtems_rfs_mutex_create>: RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL) #endif int rtems_rfs_mutex_create (rtems_rfs_mutex* mutex) {
 201eea4:	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'), 
 201eea8:	11 14 91 94 	sethi  %hi(0x52465000), %o0                    
 201eeac:	98 10 00 18 	mov  %i0, %o4                                  
 201eeb0:	90 12 23 6d 	or  %o0, 0x36d, %o0                            
 201eeb4:	92 10 20 01 	mov  1, %o1                                    
 201eeb8:	94 10 20 54 	mov  0x54, %o2                                 
 201eebc:	96 10 20 00 	clr  %o3                                       
 201eec0:	7f ff b6 3e 	call  200c7b8 <rtems_semaphore_create>         
 201eec4:	b0 10 20 00 	clr  %i0                                       
                               1, RTEMS_RFS_MUTEX_ATTRIBS, 0,         
                               mutex);                                
  if (sc != RTEMS_SUCCESSFUL)                                         
 201eec8:	80 a2 20 00 	cmp  %o0, 0                                    
 201eecc:	02 80 00 0f 	be  201ef08 <rtems_rfs_mutex_create+0x64>      <== ALWAYS TAKEN
 201eed0:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 201eed4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201eed8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 201eedc:	7f ff d2 0b 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201eee0:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 201eee4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201eee8:	02 80 00 08 	be  201ef08 <rtems_rfs_mutex_create+0x64>      <== NOT EXECUTED
 201eeec:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: open failed: %s\n",                  
 201eef0:	7f ff a3 a1 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201eef4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201eef8:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 201eefc:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201ef00:	40 00 0c 21 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ef04:	90 12 23 38 	or  %o0, 0x338, %o0	! 2034b38 <CSWTCH.2+0x1658><== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
 201ef08:	81 c7 e0 08 	ret                                            
 201ef0c:	81 e8 00 00 	restore                                        
                                                                      

0201ef10 <rtems_rfs_mutex_destroy>: int rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex) {
 201ef10:	9d e3 bf a0 	save  %sp, -96, %sp                            
#if __rtems__                                                         
  rtems_status_code sc;                                               
  sc = rtems_semaphore_delete (*mutex);                               
 201ef14:	d0 06 00 00 	ld  [ %i0 ], %o0                               
 201ef18:	7f ff b6 96 	call  200c970 <rtems_semaphore_delete>         
 201ef1c:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 201ef20:	80 a2 20 00 	cmp  %o0, 0                                    
 201ef24:	02 80 00 0f 	be  201ef60 <rtems_rfs_mutex_destroy+0x50>     <== ALWAYS TAKEN
 201ef28:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 201ef2c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201ef30:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 201ef34:	7f ff d1 f5 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201ef38:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 201ef3c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201ef40:	02 80 00 08 	be  201ef60 <rtems_rfs_mutex_destroy+0x50>     <== NOT EXECUTED
 201ef44:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: close failed: %s\n",                 
 201ef48:	7f ff a3 8b 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201ef4c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ef50:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 201ef54:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201ef58:	40 00 0c 0b 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ef5c:	90 12 23 60 	or  %o0, 0x360, %o0	! 2034b60 <CSWTCH.2+0x1680><== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
 201ef60:	81 c7 e0 08 	ret                                            
 201ef64:	81 e8 00 00 	restore                                        
                                                                      

0201f180 <rtems_rfs_mutex_lock.isra.0>: * @param mutex The mutex to lock. * @retval true The mutex is locked. * @retval false The mutex could not be locked. */ static inline int rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
 201f180:	9d e3 bf a0 	save  %sp, -96, %sp                            
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
 201f184:	92 10 20 00 	clr  %o1                                       
 201f188:	90 10 00 18 	mov  %i0, %o0                                  
 201f18c:	94 10 20 00 	clr  %o2                                       
 201f190:	7f ff b6 27 	call  200ca2c <rtems_semaphore_obtain>         
 201f194:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 201f198:	80 a2 20 00 	cmp  %o0, 0                                    
 201f19c:	02 80 00 0f 	be  201f1d8 <rtems_rfs_mutex_lock.isra.0+0x58> <== ALWAYS TAKEN
 201f1a0:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 201f1a4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201f1a8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 201f1ac:	7f ff d1 57 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201f1b0:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 201f1b4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201f1b8:	02 80 00 08 	be  201f1d8 <rtems_rfs_mutex_lock.isra.0+0x58> <== NOT EXECUTED
 201f1bc:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
 201f1c0:	7f ff a2 ed 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201f1c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201f1c8:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 201f1cc:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 201f1d0:	40 00 0b 6d 	call  2021f84 <printf>                         <== NOT EXECUTED
 201f1d4:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif                                                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
 201f1d8:	81 c7 e0 08 	ret                                            
 201f1dc:	81 e8 00 00 	restore                                        
                                                                      

02012ccc <rtems_rfs_mutex_lock.isra.2>: * @param mutex The mutex to lock. * @retval true The mutex is locked. * @retval false The mutex could not be locked. */ static inline int rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
 2012ccc:	9d e3 bf a0 	save  %sp, -96, %sp                            
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
 2012cd0:	92 10 20 00 	clr  %o1                                       
 2012cd4:	90 10 00 18 	mov  %i0, %o0                                  
 2012cd8:	94 10 20 00 	clr  %o2                                       
 2012cdc:	7f ff e7 54 	call  200ca2c <rtems_semaphore_obtain>         
 2012ce0:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 2012ce4:	80 a2 20 00 	cmp  %o0, 0                                    
 2012ce8:	02 80 00 0f 	be  2012d24 <rtems_rfs_mutex_lock.isra.2+0x58> <== ALWAYS TAKEN
 2012cec:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 2012cf0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 2012cf4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 2012cf8:	40 00 02 84 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 2012cfc:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 2012d00:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2012d04:	02 80 00 08 	be  2012d24 <rtems_rfs_mutex_lock.isra.2+0x58> <== NOT EXECUTED
 2012d08:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
 2012d0c:	7f ff d4 1a 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 2012d10:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2012d14:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 2012d18:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 2012d1c:	40 00 3c 9a 	call  2021f84 <printf>                         <== NOT EXECUTED
 2012d20:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif                                                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
 2012d24:	81 c7 e0 08 	ret                                            
 2012d28:	81 e8 00 00 	restore                                        
                                                                      

02012c74 <rtems_rfs_mutex_unlock.isra.1>: * @param mutex The mutex to unlock. * @retval true The mutex is unlocked. * @retval false The mutex could not be unlocked. */ static inline int rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
 2012c74:	9d e3 bf a0 	save  %sp, -96, %sp                            
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
 2012c78:	90 10 00 18 	mov  %i0, %o0                                  
 2012c7c:	7f ff e7 b5 	call  200cb50 <rtems_semaphore_release>        
 2012c80:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 2012c84:	80 a2 20 00 	cmp  %o0, 0                                    
 2012c88:	02 80 00 0f 	be  2012cc4 <rtems_rfs_mutex_unlock.isra.1+0x50><== ALWAYS TAKEN
 2012c8c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 2012c90:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 2012c94:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 2012c98:	40 00 02 9c 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 2012c9c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
 2012ca0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 2012ca4:	02 80 00 08 	be  2012cc4 <rtems_rfs_mutex_unlock.isra.1+0x50><== NOT EXECUTED
 2012ca8:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
 2012cac:	7f ff d4 32 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 2012cb0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2012cb4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 2012cb8:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 2012cbc:	40 00 3c b2 	call  2021f84 <printf>                         <== NOT EXECUTED
 2012cc0:	90 12 20 c8 	or  %o0, 0xc8, %o0	! 2032cc8 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
#endif                                                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
 2012cc4:	81 c7 e0 08 	ret                                            
 2012cc8:	81 e8 00 00 	restore                                        
                                                                      

0201b0a8 <rtems_rfs_release_chain>: static int rtems_rfs_release_chain (rtems_chain_control* chain, uint32_t* count, bool modified) {
 201b0a8:	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))                
 201b0ac:	90 10 20 00 	clr  %o0                                       
 201b0b0:	92 10 20 80 	mov  0x80, %o1                                 
 201b0b4:	7f ff e1 95 	call  2013708 <rtems_rfs_trace>                
 201b0b8:	ba 10 00 18 	mov  %i0, %i5                                  
 201b0bc:	80 8a 20 ff 	btst  0xff, %o0                                
 201b0c0:	22 80 00 07 	be,a   201b0dc <rtems_rfs_release_chain+0x34>  <== ALWAYS TAKEN
 201b0c4:	b0 10 20 00 	clr  %i0                                       
    printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count); 
 201b0c8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 201b0cc:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b0d0:	40 00 1b ad 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b0d4:	90 12 21 e8 	or  %o0, 0x1e8, %o0	! 20335e8 <CSWTCH.2+0x108> <== NOT EXECUTED
    (*count)--;                                                       
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
 201b0d8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 201b0dc:	10 80 00 10 	b  201b11c <rtems_rfs_release_chain+0x74>      
 201b0e0:	b8 07 60 04 	add  %i5, 4, %i4                               
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
 201b0e4:	7f ff c9 28 	call  200d584 <_Chain_Get>                     
 201b0e8:	90 10 00 1d 	mov  %i5, %o0                                  
    printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count); 
                                                                      
  while (!rtems_chain_is_empty (chain))                               
  {                                                                   
    buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);             
    (*count)--;                                                       
 201b0ec:	c2 06 40 00 	ld  [ %i1 ], %g1                               
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
 201b0f0:	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)--;                                                       
 201b0f4:	82 00 7f ff 	add  %g1, -1, %g1                              
 201b0f8:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
 201b0fc:	40 00 15 31 	call  20205c0 <rtems_rfs_buffer_bdbuf_release> 
 201b100:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
    if ((rc > 0) && (rrc == 0))                                       
 201b104:	80 a2 20 00 	cmp  %o0, 0                                    
 201b108:	24 80 00 06 	ble,a   201b120 <rtems_rfs_release_chain+0x78> <== ALWAYS TAKEN
 201b10c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 201b110:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
 201b114:	22 80 00 02 	be,a   201b11c <rtems_rfs_release_chain+0x74>  <== NOT EXECUTED
 201b118:	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))                               
 201b11c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
 201b120:	80 a0 40 1c 	cmp  %g1, %i4                                  
 201b124:	12 bf ff f0 	bne  201b0e4 <rtems_rfs_release_chain+0x3c>    
 201b128:	01 00 00 00 	nop                                            
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
      rrc = rc;                                                       
  }                                                                   
  return rrc;                                                         
}                                                                     
 201b12c:	81 c7 e0 08 	ret                                            
 201b130:	81 e8 00 00 	restore                                        
                                                                      

02012978 <rtems_rfs_rtems_chown>: static int rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc, uid_t owner, gid_t group) {
 2012978:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
 201297c:	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);                  
 2012980:	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);  
 2012984:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
  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);                  
 2012988:	94 07 bf d8 	add  %fp, -40, %o2                             
 201298c:	90 10 00 1d 	mov  %i5, %o0                                  
 2012990:	7f ff fc d5 	call  2011ce4 <rtems_rfs_inode_open>           
 2012994:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 2012998:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201299c:	04 80 00 07 	ble  20129b8 <rtems_rfs_rtems_chown+0x40>      <== ALWAYS TAKEN
 20129a0:	01 00 00 00 	nop                                            
  {                                                                   
    return rtems_rfs_rtems_error ("chown: opening inode", rc);        
 20129a4:	40 00 38 1f 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20129a8:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 20129ac:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 20129b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20129b4:	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();                                                    
 20129b8:	40 00 10 fa 	call  2016da0 <geteuid>                        
 20129bc:	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;          
 20129c0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
 20129c4:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 20129c8:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
 20129cc:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
 20129d0:	85 28 a0 08 	sll  %g2, 8, %g2                               
 20129d4:	84 10 80 03 	or  %g2, %g3, %g2                              
 20129d8:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20129dc:	80 a0 80 08 	cmp  %g2, %o0                                  
 20129e0:	02 80 00 0e 	be  2012a18 <rtems_rfs_rtems_chown+0xa0>       <== ALWAYS TAKEN
 20129e4:	87 32 20 10 	srl  %o0, 0x10, %g3                            
 20129e8:	80 a0 e0 00 	cmp  %g3, 0                                    <== NOT EXECUTED
 20129ec:	22 80 00 0c 	be,a   2012a1c <rtems_rfs_rtems_chown+0xa4>    <== NOT EXECUTED
 20129f0:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
 20129f4:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 20129f8:	7f ff fd 2d 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 20129fc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("chown: not able", EPERM);          
 2012a00:	40 00 38 08 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012a04:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012a08:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2012a0c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2012a10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012a14:	81 e8 00 00 	restore                                        <== 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);
 2012a18:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            
 2012a1c:	b4 16 80 19 	or  %i2, %i1, %i2                              
 2012a20:	85 36 a0 18 	srl  %i2, 0x18, %g2                            
 2012a24:	c4 28 60 04 	stb  %g2, [ %g1 + 4 ]                          
 2012a28:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 2012a2c:	85 36 a0 10 	srl  %i2, 0x10, %g2                            
 2012a30:	c4 28 60 05 	stb  %g2, [ %g1 + 5 ]                          
 2012a34:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 2012a38:	b5 36 a0 08 	srl  %i2, 8, %i2                               
 2012a3c:	f4 28 60 06 	stb  %i2, [ %g1 + 6 ]                          
 2012a40:	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);                            
 2012a44:	90 10 00 1d 	mov  %i5, %o0                                  
 2012a48:	f2 28 60 07 	stb  %i1, [ %g1 + 7 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 2012a4c:	82 10 20 01 	mov  1, %g1                                    
 2012a50:	92 07 bf d8 	add  %fp, -40, %o1                             
 2012a54:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
 2012a58:	7f ff fd 15 	call  2011eac <rtems_rfs_inode_close>          
 2012a5c:	b0 10 20 00 	clr  %i0                                       
  if (rc)                                                             
 2012a60:	80 a2 20 00 	cmp  %o0, 0                                    
 2012a64:	02 80 00 05 	be  2012a78 <rtems_rfs_rtems_chown+0x100>      <== ALWAYS TAKEN
 2012a68:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("chown: closing inode", rc);        
 2012a6c:	40 00 37 ed 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012a70:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012a74:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2012a78:	81 c7 e0 08 	ret                                            
 2012a7c:	81 e8 00 00 	restore                                        
                                                                      

0201efec <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);
 201efec:	d2 02 20 2c 	ld  [ %o0 + 0x2c ], %o1                        <== NOT EXECUTED
 201eff0:	d4 02 20 30 	ld  [ %o0 + 0x30 ], %o2                        <== NOT EXECUTED
 201eff4:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 201eff8:	40 00 03 37 	call  201fcd4 <rtems_deviceio_close>           <== NOT EXECUTED
 201effc:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

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

0201efb0 <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);
 201efb0:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
 201efb4:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
 201efb8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 201efbc:	40 00 03 86 	call  201fdd4 <rtems_deviceio_control>         <== NOT EXECUTED
 201efc0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

0201f054 <rtems_rfs_rtems_device_open>: static int rtems_rfs_rtems_device_open ( rtems_libio_t *iop, const char *pathname, int oflag, mode_t mode) {
 201f054:	9d e3 bf 78 	save  %sp, -136, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
 201f058:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_iop_ino (iop);
 201f05c:	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);
 201f060:	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);
 201f064:	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                       
};                                                                    
 201f068:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        <== NOT EXECUTED
 201f06c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201f070:	7f ff b6 6f 	call  200ca2c <rtems_semaphore_obtain>         <== NOT EXECUTED
 201f074:	d0 00 40 00 	ld  [ %g1 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
 201f078:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
 201f07c:	02 80 00 0f 	be  201f0b8 <rtems_rfs_rtems_device_open+0x64> <== NOT EXECUTED
 201f080:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 201f084:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201f088:	7f ff d1 a0 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201f08c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 201f090:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201f094:	22 80 00 09 	be,a   201f0b8 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
 201f098:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
 201f09c:	7f ff a3 36 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201f0a0:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201f0a4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
 201f0a8:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 201f0ac:	40 00 0b b6 	call  2021f84 <printf>                         <== NOT EXECUTED
 201f0b0:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
  rtems_device_minor_number     minor;                                
  int                           rc;                                   
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
 201f0b4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201f0b8:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 201f0bc:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
 201f0c0:	7f ff cb 09 	call  2011ce4 <rtems_rfs_inode_open>           <== NOT EXECUTED
 201f0c4:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc > 0)                                                         
 201f0c8:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
 201f0cc:	04 80 00 09 	ble  201f0f0 <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
 201f0d0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
 201f0d4:	7f ff ff cb 	call  201f000 <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f0d8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: opening inode", rc);  
 201f0dc:	40 00 06 51 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f0e0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201f0e4:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 201f0e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f0ec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  major = rtems_rfs_inode_get_block (&inode, 0);                      
 201f0f0:	7f ff ff 9e 	call  201ef68 <rtems_rfs_inode_get_block>      <== NOT EXECUTED
 201f0f4:	90 07 bf d8 	add  %fp, -40, %o0                             <== NOT EXECUTED
  minor = rtems_rfs_inode_get_block (&inode, 1);                      
 201f0f8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("device_open: opening inode", rc);  
  }                                                                   
                                                                      
  major = rtems_rfs_inode_get_block (&inode, 0);                      
 201f0fc:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
  minor = rtems_rfs_inode_get_block (&inode, 1);                      
 201f100:	7f ff ff 9a 	call  201ef68 <rtems_rfs_inode_get_block>      <== NOT EXECUTED
 201f104:	90 07 bf d8 	add  %fp, -40, %o0                             <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 201f108:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("device_open: opening inode", rc);  
  }                                                                   
                                                                      
  major = rtems_rfs_inode_get_block (&inode, 0);                      
  minor = rtems_rfs_inode_get_block (&inode, 1);                      
 201f10c:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 201f110:	7f ff cb 67 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201f114:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201f118:	a2 10 00 08 	mov  %o0, %l1                                  <== NOT EXECUTED
  if (rc > 0)                                                         
 201f11c:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
 201f120:	04 80 00 09 	ble  201f144 <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
 201f124:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
 201f128:	7f ff ff b6 	call  201f000 <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f12c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
 201f130:	40 00 06 3c 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f134:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201f138:	e2 22 00 00 	st  %l1, [ %o0 ]                               <== NOT EXECUTED
 201f13c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f140:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
 201f144:	7f ff ff af 	call  201f000 <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f148:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  iop->data0 = major;                                                 
  iop->data1 = (void *) minor;                                        
                                                                      
  return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
 201f14c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("device_open: closing inode", rc);  
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  iop->data0 = major;                                                 
 201f150:	f8 26 20 2c 	st  %i4, [ %i0 + 0x2c ]                        <== NOT EXECUTED
  iop->data1 = (void *) minor;                                        
 201f154:	e0 26 20 30 	st  %l0, [ %i0 + 0x30 ]                        <== NOT EXECUTED
                                                                      
  return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
 201f158:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201f15c:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 201f160:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
 201f164:	98 10 00 10 	mov  %l0, %o4                                  <== NOT EXECUTED
 201f168:	40 00 02 ce 	call  201fca0 <rtems_deviceio_open>            <== NOT EXECUTED
 201f16c:	9a 10 00 1c 	mov  %i4, %o5                                  <== NOT EXECUTED
}                                                                     
 201f170:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f174:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

0201efd8 <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);
 201efd8:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
 201efdc:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
 201efe0:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 201efe4:	40 00 03 48 	call  201fd04 <rtems_deviceio_read>            <== NOT EXECUTED
 201efe8:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

0201efc4 <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);
 201efc4:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
 201efc8:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
 201efcc:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
 201efd0:	40 00 03 67 	call  201fd6c <rtems_deviceio_write>           <== NOT EXECUTED
 201efd4:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

0201f324 <rtems_rfs_rtems_dir_open>: static int rtems_rfs_rtems_dir_open (rtems_libio_t* iop, const char* pathname, int oflag, mode_t mode) {
 201f324:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
 201f328:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
 201f32c:	f8 06 20 1c 	ld  [ %i0 + 0x1c ], %i4                        
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);
 201f330:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
  .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                       
};                                                                    
 201f334:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 201f338:	7f ff ff 92 	call  201f180 <rtems_rfs_mutex_lock.isra.0>    
 201f33c:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
 201f340:	92 10 00 1c 	mov  %i4, %o1                                  
 201f344:	90 10 00 1d 	mov  %i5, %o0                                  
 201f348:	94 07 bf d8 	add  %fp, -40, %o2                             
 201f34c:	7f ff ca 66 	call  2011ce4 <rtems_rfs_inode_open>           
 201f350:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201f354:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201f358:	02 80 00 09 	be  201f37c <rtems_rfs_rtems_dir_open+0x58>    <== ALWAYS TAKEN
 201f35c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
 201f360:	7f ff ff a0 	call  201f1e0 <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f364:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_open: opening inode", rc);     
 201f368:	40 00 05 ae 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f36c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201f370:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 201f374:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f378:	81 e8 00 00 	restore                                        <== 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);                    
 201f37c:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
  }                                                                   
                                                                      
  if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))         
 201f380:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 201f384:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201f388:	84 08 80 01 	and  %g2, %g1, %g2                             
 201f38c:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
 201f390:	80 a0 80 01 	cmp  %g2, %g1                                  
 201f394:	02 80 00 0c 	be  201f3c4 <rtems_rfs_rtems_dir_open+0xa0>    <== ALWAYS TAKEN
 201f398:	92 07 bf d8 	add  %fp, -40, %o1                             
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
 201f39c:	7f ff ca c4 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201f3a0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
 201f3a4:	7f ff ff 8f 	call  201f1e0 <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f3a8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);      
 201f3ac:	40 00 05 9d 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f3b0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201f3b4:	82 10 20 14 	mov  0x14, %g1                                 <== NOT EXECUTED
 201f3b8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 201f3bc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f3c0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  iop->offset = 0;                                                    
 201f3c4:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
 201f3c8:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
 201f3cc:	7f ff ca b8 	call  2011eac <rtems_rfs_inode_close>          
 201f3d0:	90 10 00 1d 	mov  %i5, %o0                                  
  rtems_rfs_rtems_unlock (fs);                                        
 201f3d4:	90 10 00 1d 	mov  %i5, %o0                                  
 201f3d8:	7f ff ff 82 	call  201f1e0 <rtems_rfs_rtems_unlock>         
 201f3dc:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
 201f3e0:	81 c7 e0 08 	ret                                            
 201f3e4:	81 e8 00 00 	restore                                        
                                                                      

0201f234 <rtems_rfs_rtems_dir_read>: */ static ssize_t rtems_rfs_rtems_dir_read (rtems_libio_t* iop, void* buffer, size_t count) {
 201f234:	9d e3 bf 70 	save  %sp, -144, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
 201f238:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
 201f23c:	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);
 201f240:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
  count  = count / sizeof (struct dirent);                            
  dirent = buffer;                                                    
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
 201f244:	a0 07 bf d8 	add  %fp, -40, %l0                             
  .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                       
};                                                                    
 201f248:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 */                                                                   
static inline void                                                    
 rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)                     
{                                                                     
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
  rtems_rfs_mutex_lock (&rtems->access);                              
 201f24c:	7f ff ff cd 	call  201f180 <rtems_rfs_mutex_lock.isra.0>    
 201f250:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  count  = count / sizeof (struct dirent);                            
  dirent = buffer;                                                    
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
 201f254:	92 10 00 1c 	mov  %i4, %o1                                  
 201f258:	90 10 00 1d 	mov  %i5, %o0                                  
 201f25c:	94 10 00 10 	mov  %l0, %o2                                  
 201f260:	7f ff ca a1 	call  2011ce4 <rtems_rfs_inode_open>           
 201f264:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201f268:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201f26c:	02 80 00 1f 	be  201f2e8 <rtems_rfs_rtems_dir_read+0xb4>    <== ALWAYS TAKEN
 201f270:	90 10 00 1a 	mov  %i2, %o0                                  
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
 201f274:	7f ff ff db 	call  201f1e0 <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f278:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
 201f27c:	40 00 05 e9 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f280:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201f284:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 201f288:	10 80 00 25 	b  201f31c <rtems_rfs_rtems_dir_read+0xe8>     <== NOT EXECUTED
 201f28c:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
  {                                                                   
    size_t size;                                                      
    rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size); 
 201f290:	d4 1e 20 08 	ldd  [ %i0 + 8 ], %o2                          
 201f294:	90 10 00 1d 	mov  %i5, %o0                                  
 201f298:	92 10 00 10 	mov  %l0, %o1                                  
 201f29c:	7f ff f5 35 	call  201c770 <rtems_rfs_dir_read>             
 201f2a0:	9a 07 bf d4 	add  %fp, -44, %o5                             
    if (rc == ENOENT)                                                 
 201f2a4:	80 a2 20 02 	cmp  %o0, 2                                    
 201f2a8:	02 80 00 18 	be  201f308 <rtems_rfs_rtems_dir_read+0xd4>    
 201f2ac:	b4 10 00 08 	mov  %o0, %i2                                  
    {                                                                 
      rc = 0;                                                         
      break;                                                          
    }                                                                 
    if (rc > 0)                                                       
 201f2b0:	80 a2 20 00 	cmp  %o0, 0                                    
 201f2b4:	24 80 00 06 	ble,a   201f2cc <rtems_rfs_rtems_dir_read+0x98><== ALWAYS TAKEN
 201f2b8:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
 201f2bc:	40 00 05 d9 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f2c0:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
 201f2c4:	10 80 00 11 	b  201f308 <rtems_rfs_rtems_dir_read+0xd4>     <== NOT EXECUTED
 201f2c8:	f4 22 00 00 	st  %i2, [ %o0 ]                               <== NOT EXECUTED
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
 201f2cc:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1                         
 * 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,                         
 201f2d0:	b8 07 21 18 	add  %i4, 0x118, %i4                           
    if (rc > 0)                                                       
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
 201f2d4:	86 80 c0 01 	addcc  %g3, %g1, %g3                           
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
 201f2d8:	b6 06 e0 01 	inc  %i3                                       
    if (rc > 0)                                                       
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
 201f2dc:	84 40 a0 00 	addx  %g2, 0, %g2                              
 201f2e0:	10 80 00 07 	b  201f2fc <rtems_rfs_rtems_dir_read+0xc8>     
 201f2e4:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
  struct dirent*         dirent;                                      
  ssize_t                bytes_transferred;                           
  int                    d;                                           
  int                    rc;                                          
                                                                      
  count  = count / sizeof (struct dirent);                            
 201f2e8:	92 10 21 18 	mov  0x118, %o1                                
 201f2ec:	7f ff 8c e4 	call  200267c <.udiv>                          
 201f2f0:	b6 10 20 00 	clr  %i3                                       
 * 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,                         
 201f2f4:	b8 10 20 00 	clr  %i4                                       
  struct dirent*         dirent;                                      
  ssize_t                bytes_transferred;                           
  int                    d;                                           
  int                    rc;                                          
                                                                      
  count  = count / sizeof (struct dirent);                            
 201f2f8:	a2 10 00 08 	mov  %o0, %l1                                  
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
  }                                                                   
                                                                      
  bytes_transferred = 0;                                              
                                                                      
  for (d = 0; d < count; d++, dirent++)                               
 201f2fc:	80 a6 c0 11 	cmp  %i3, %l1                                  
 201f300:	12 bf ff e4 	bne  201f290 <rtems_rfs_rtems_dir_read+0x5c>   
 201f304:	98 06 40 1c 	add  %i1, %i4, %o4                             
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
 201f308:	90 10 00 1d 	mov  %i5, %o0                                  
 201f30c:	7f ff ca e8 	call  2011eac <rtems_rfs_inode_close>          
 201f310:	92 07 bf d8 	add  %fp, -40, %o1                             
  rtems_rfs_rtems_unlock (fs);                                        
 201f314:	7f ff ff b3 	call  201f1e0 <rtems_rfs_rtems_unlock>         
 201f318:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return bytes_transferred;                                           
}                                                                     
 201f31c:	81 c7 e0 08 	ret                                            
 201f320:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                                                                      

02012bd0 <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) {
 2012bd0:	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);
 2012bd4:	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);                  
 2012bd8:	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);
 2012bdc:	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);                  
 2012be0:	94 07 bf d8 	add  %fp, -40, %o2                             
 2012be4:	90 10 00 1d 	mov  %i5, %o0                                  
 2012be8:	7f ff fc 3f 	call  2011ce4 <rtems_rfs_inode_open>           
 2012bec:	96 10 20 01 	mov  1, %o3                                    
  if (rc == 0) {                                                      
 2012bf0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2012bf4:	12 80 00 10 	bne  2012c34 <rtems_rfs_rtems_eval_path+0x64>  <== NEVER TAKEN
 2012bf8:	90 10 00 18 	mov  %i0, %o0                                  
    rtems_filesystem_eval_path_generic (                              
 2012bfc:	92 07 bf d8 	add  %fp, -40, %o1                             
 2012c00:	15 00 80 cb 	sethi  %hi(0x2032c00), %o2                     
 2012c04:	40 00 11 68 	call  20171a4 <rtems_filesystem_eval_path_generic>
 2012c08:	94 12 a1 d8 	or  %o2, 0x1d8, %o2	! 2032dd8 <rtems_rfs_rtems_eval_config>
      ctx,                                                            
      &inode,                                                         
      &rtems_rfs_rtems_eval_config                                    
    );                                                                
    rc = rtems_rfs_inode_close (fs, &inode);                          
 2012c0c:	90 10 00 1d 	mov  %i5, %o0                                  
 2012c10:	7f ff fc a7 	call  2011eac <rtems_rfs_inode_close>          
 2012c14:	92 07 bf d8 	add  %fp, -40, %o1                             
    if (rc != 0) {                                                    
 2012c18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2012c1c:	02 80 00 0c 	be  2012c4c <rtems_rfs_rtems_eval_path+0x7c>   <== ALWAYS TAKEN
 2012c20:	01 00 00 00 	nop                                            
      rtems_filesystem_eval_path_error (                              
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
 2012c24:	40 00 37 7f 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012c28:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012c2c:	10 80 00 05 	b  2012c40 <rtems_rfs_rtems_eval_path+0x70>    <== NOT EXECUTED
 2012c30:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
      );                                                              
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error (                                
      ctx,                                                            
      rtems_rfs_rtems_error ("eval_path: opening inode", rc)          
 2012c34:	40 00 37 7b 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012c38:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012c3c:	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 (                                
 2012c40:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 2012c44:	7f ff da 95 	call  2009698 <rtems_filesystem_eval_path_error><== NOT EXECUTED
 2012c48:	92 10 3f ff 	mov  -1, %o1                                   <== NOT EXECUTED
 2012c4c:	81 c7 e0 08 	ret                                            
 2012c50:	81 e8 00 00 	restore                                        
                                                                      

02013028 <rtems_rfs_rtems_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
 2013028:	9d e3 bf 90 	save  %sp, -112, %sp                           
 201302c:	f8 06 60 0c 	ld  [ %i1 + 0xc ], %i4                         
 2013030:	ba 10 00 18 	mov  %i0, %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;          
 2013034:	c2 0f 20 07 	ldub  [ %i4 + 7 ], %g1                         
 2013038:	f0 0f 20 06 	ldub  [ %i4 + 6 ], %i0                         
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(                     
 201303c:	90 10 00 19 	mov  %i1, %o0                                  
 2013040:	b1 2e 20 08 	sll  %i0, 8, %i0                               
 2013044:	7f ff fd 5a 	call  20125ac <rtems_rfs_inode_get_gid>        
 2013048:	b0 16 00 01 	or  %i0, %g1, %i0                              
 * @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);                    
 201304c:	c2 0f 20 02 	ldub  [ %i4 + 2 ], %g1                         
 2013050:	d4 0f 20 03 	ldub  [ %i4 + 3 ], %o2                         
 2013054:	83 28 60 08 	sll  %g1, 8, %g1                               
 2013058:	97 2e 20 10 	sll  %i0, 0x10, %o3                            
 201305c:	99 2a 20 10 	sll  %o0, 0x10, %o4                            
 2013060:	92 10 20 01 	mov  1, %o1                                    
 2013064:	90 10 00 1d 	mov  %i5, %o0                                  
 2013068:	94 12 80 01 	or  %o2, %g1, %o2                              
 201306c:	97 32 e0 10 	srl  %o3, 0x10, %o3                            
 2013070:	99 33 20 10 	srl  %o4, 0x10, %o4                            
 2013074:	40 00 10 3e 	call  201716c <rtems_filesystem_eval_path_check_access>
 2013078:	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) {                                                    
 201307c:	80 8a 20 ff 	btst  0xff, %o0                                
 2013080:	02 80 00 71 	be  2013244 <rtems_rfs_rtems_eval_token+0x21c> 
 2013084:	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] == '.';                           
 2013088:	12 80 00 06 	bne  20130a0 <rtems_rfs_rtems_eval_token+0x78> 
 201308c:	82 10 20 00 	clr  %g1                                       
 2013090:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
 2013094:	82 18 60 2e 	xor  %g1, 0x2e, %g1                            
 2013098:	80 a0 00 01 	cmp  %g0, %g1                                  
 201309c:	82 60 3f ff 	subx  %g0, -1, %g1                             
    if (rtems_filesystem_is_current_directory (token, tokenlen)) {    
 20130a0:	80 a0 60 00 	cmp  %g1, 0                                    
 20130a4:	22 80 00 04 	be,a   20130b4 <rtems_rfs_rtems_eval_token+0x8c>
 20130a8:	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;                                                  
 20130ac:	10 80 00 44 	b  20131bc <rtems_rfs_rtems_eval_token+0x194>  
 20130b0:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
      rtems_filesystem_location_info_t *currentloc =                  
        rtems_filesystem_eval_path_get_currentloc( ctx );             
      rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
      rtems_rfs_ino entry_ino;                                        
      uint32_t entry_doff;                                            
      int rc = rtems_rfs_dir_lookup_ino (                             
 20130b4:	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);
 20130b8:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
      rtems_rfs_ino entry_ino;                                        
      uint32_t entry_doff;                                            
      int rc = rtems_rfs_dir_lookup_ino (                             
 20130bc:	94 10 00 1a 	mov  %i2, %o2                                  
 20130c0:	90 10 00 1c 	mov  %i4, %o0                                  
 20130c4:	96 10 00 1b 	mov  %i3, %o3                                  
 20130c8:	98 07 bf f4 	add  %fp, -12, %o4                             
 20130cc:	9a 07 bf f8 	add  %fp, -8, %o5                              
 20130d0:	40 00 22 89 	call  201baf4 <rtems_rfs_dir_lookup_ino>       
 20130d4:	b0 10 20 02 	mov  2, %i0                                    
        tokenlen,                                                     
        &entry_ino,                                                   
        &entry_doff                                                   
      );                                                              
                                                                      
      if (rc == 0) {                                                  
 20130d8:	80 a2 20 00 	cmp  %o0, 0                                    
 20130dc:	12 80 00 5a 	bne  2013244 <rtems_rfs_rtems_eval_token+0x21c>
 20130e0:	90 10 00 1c 	mov  %i4, %o0                                  
        rc = rtems_rfs_inode_close (fs, inode);                       
 20130e4:	7f ff fb 72 	call  2011eac <rtems_rfs_inode_close>          
 20130e8:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc == 0) {                                                
 20130ec:	80 a2 20 00 	cmp  %o0, 0                                    
 20130f0:	02 80 00 07 	be  201310c <rtems_rfs_rtems_eval_token+0xe4>  <== ALWAYS TAKEN
 20130f4:	90 10 00 19 	mov  %i1, %o0                                  
        if (rc != 0) {                                                
          /*                                                          
           * This prevents the rtems_rfs_inode_close() from doing something in
           * rtems_rfs_rtems_eval_path().                             
           */                                                         
          memset (inode, 0, sizeof(*inode));                          
 20130f8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 20130fc:	40 00 3b 24 	call  2021d8c <memset>                         <== NOT EXECUTED
 2013100:	94 10 20 28 	mov  0x28, %o2                                 <== NOT EXECUTED
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 2013104:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013108:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
      );                                                              
                                                                      
      if (rc == 0) {                                                  
        rc = rtems_rfs_inode_close (fs, inode);                       
        if (rc == 0) {                                                
          rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);     
 201310c:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
 2013110:	90 10 00 1c 	mov  %i4, %o0                                  
 2013114:	94 10 00 19 	mov  %i1, %o2                                  
 2013118:	7f ff fa f3 	call  2011ce4 <rtems_rfs_inode_open>           
 201311c:	96 10 20 01 	mov  1, %o3                                    
        }                                                             
                                                                      
        if (rc != 0) {                                                
 2013120:	80 a2 20 00 	cmp  %o0, 0                                    
 2013124:	02 80 00 2f 	be  20131e0 <rtems_rfs_rtems_eval_token+0x1b8> <== ALWAYS TAKEN
 2013128:	90 10 00 19 	mov  %i1, %o0                                  
          /*                                                          
           * This prevents the rtems_rfs_inode_close() from doing something in
           * rtems_rfs_rtems_eval_path().                             
           */                                                         
          memset (inode, 0, sizeof(*inode));                          
 201312c:	10 bf ff f4 	b  20130fc <rtems_rfs_rtems_eval_token+0xd4>   <== NOT EXECUTED
 2013130:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
        bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
                                                                      
        rtems_filesystem_eval_path_clear_token (ctx);                 
                                                                      
        if (is_sym_link && (follow_sym_link || !terminal)) {          
 2013134:	02 80 00 04 	be  2013144 <rtems_rfs_rtems_eval_token+0x11c> 
 2013138:	80 88 a0 ff 	btst  0xff, %g2                                
 201313c:	02 80 00 23 	be  20131c8 <rtems_rfs_rtems_eval_token+0x1a0> 
 2013140:	90 07 60 18 	add  %i5, 0x18, %o0                            
  rtems_filesystem_eval_path_context_t* ctx,                          
  rtems_rfs_file_system* fs,                                          
  rtems_rfs_ino ino                                                   
)                                                                     
{                                                                     
  size_t len = MAXPATHLEN;                                            
 2013144:	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);           
 2013148:	f4 07 bf f4 	ld  [ %fp + -12 ], %i2                         
  rtems_filesystem_eval_path_context_t* ctx,                          
  rtems_rfs_file_system* fs,                                          
  rtems_rfs_ino ino                                                   
)                                                                     
{                                                                     
  size_t len = MAXPATHLEN;                                            
 201314c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
  char *link = malloc(len + 1);                                       
 2013150:	7f ff d5 36 	call  2008628 <malloc>                         
 2013154:	90 10 24 01 	mov  0x401, %o0                                
                                                                      
  if (link != NULL) {                                                 
 2013158:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 201315c:	02 80 00 14 	be  20131ac <rtems_rfs_rtems_eval_token+0x184> <== NEVER TAKEN
 2013160:	90 10 00 1c 	mov  %i4, %o0                                  
    int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);       
 2013164:	92 10 00 1a 	mov  %i2, %o1                                  
 2013168:	94 10 00 1b 	mov  %i3, %o2                                  
 201316c:	96 10 24 00 	mov  0x400, %o3                                
 2013170:	40 00 2e dc 	call  201ece0 <rtems_rfs_symlink_read>         
 2013174:	98 07 bf fc 	add  %fp, -4, %o4                              
                                                                      
    if (rc == 0) {                                                    
 2013178:	80 a2 20 00 	cmp  %o0, 0                                    
 201317c:	12 80 00 06 	bne  2013194 <rtems_rfs_rtems_eval_token+0x16c><== NEVER TAKEN
 2013180:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_filesystem_eval_path_recursive (ctx, link, len);          
 2013184:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
 2013188:	7f ff da 42 	call  2009a90 <rtems_filesystem_eval_path_recursive>
 201318c:	92 10 00 1b 	mov  %i3, %o1                                  
 2013190:	30 80 00 03 	b,a   201319c <rtems_rfs_rtems_eval_token+0x174>
    } else {                                                          
      rtems_filesystem_eval_path_error (ctx, 0);                      
 2013194:	7f ff d9 41 	call  2009698 <rtems_filesystem_eval_path_error><== NOT EXECUTED
 2013198:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    free(link);                                                       
 201319c:	7f ff d3 92 	call  2007fe4 <free>                           
 20131a0:	90 10 00 1b 	mov  %i3, %o0                                  
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 20131a4:	81 c7 e0 08 	ret                                            
 20131a8:	91 e8 20 01 	restore  %g0, 1, %o0                           
      rtems_filesystem_eval_path_error (ctx, 0);                      
    }                                                                 
                                                                      
    free(link);                                                       
  } else {                                                            
    rtems_filesystem_eval_path_error (ctx, ENOMEM);                   
 20131ac:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20131b0:	92 10 20 0c 	mov  0xc, %o1                                  <== NOT EXECUTED
 20131b4:	7f ff d9 39 	call  2009698 <rtems_filesystem_eval_path_error><== NOT EXECUTED
 20131b8:	01 00 00 00 	nop                                            <== NOT EXECUTED
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 20131bc:	81 c7 e0 08 	ret                                            
 20131c0:	91 e8 20 01 	restore  %g0, 1, %o0                           
        rtems_filesystem_eval_path_clear_token (ctx);                 
                                                                      
        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;
 20131c4:	90 07 60 18 	add  %i5, 0x18, %o0                            
 20131c8:	40 00 01 1d 	call  201363c <rtems_rfs_rtems_set_handlers>   
 20131cc:	92 10 00 19 	mov  %i1, %o1                                  
 20131d0:	80 8a 20 ff 	btst  0xff, %o0                                
 20131d4:	12 80 00 18 	bne  2013234 <rtems_rfs_rtems_eval_token+0x20c><== ALWAYS TAKEN
 20131d8:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
 20131dc:	30 80 00 0f 	b,a   2013218 <rtems_rfs_rtems_eval_token+0x1f0><== NOT EXECUTED
        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) 
 20131e0:	7f ff ff 53 	call  2012f2c <rtems_rfs_rtems_node_type_by_inode>
 20131e4:	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);   
 20131e8:	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;
 20131ec:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
 20131f0:	80 a0 00 01 	cmp  %g0, %g1                                  
 20131f4:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
 20131f8:	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;
 20131fc:	85 30 a0 04 	srl  %g2, 4, %g2                               
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
 2013200:	b0 10 00 01 	mov  %g1, %i0                                  
                                                                      
        rtems_filesystem_eval_path_clear_token (ctx);                 
                                                                      
        if (is_sym_link && (follow_sym_link || !terminal)) {          
 2013204:	80 a2 20 03 	cmp  %o0, 3                                    
 2013208:	12 bf ff ef 	bne  20131c4 <rtems_rfs_rtems_eval_token+0x19c>
 201320c:	84 08 a0 01 	and  %g2, 1, %g2                               
 2013210:	10 bf ff c9 	b  2013134 <rtems_rfs_rtems_eval_token+0x10c>  
 2013214:	80 a0 60 00 	cmp  %g1, 0                                    
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
              ctx,                                                    
              rtems_rfs_rtems_error ("eval_path: set handlers", rc)   
 2013218:	40 00 36 02 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201321c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2013220:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
                                                                      
            if (!terminal) {                                          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
 2013224:	92 10 3f ff 	mov  -1, %o1                                   <== NOT EXECUTED
              ctx,                                                    
              rtems_rfs_rtems_error ("eval_path: set handlers", rc)   
 2013228:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
            if (!terminal) {                                          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
 201322c:	10 bf ff e2 	b  20131b4 <rtems_rfs_rtems_eval_token+0x18c>  <== NOT EXECUTED
 2013230:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
 2013234:	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);  
 2013238:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
            rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
 201323c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 2013240:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
 2013244:	81 c7 e0 08 	ret                                            
 2013248:	81 e8 00 00 	restore                                        
                                                                      

020134ec <rtems_rfs_rtems_fchmod>: } static int rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc, mode_t mode) {
 20134ec:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
 20134f0:	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);                  
 20134f4:	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); 
 20134f8:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
  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);                  
 20134fc:	94 07 bf d8 	add  %fp, -40, %o2                             
 2013500:	90 10 00 1d 	mov  %i5, %o0                                  
 2013504:	7f ff f9 f8 	call  2011ce4 <rtems_rfs_inode_open>           
 2013508:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201350c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2013510:	02 80 00 07 	be  201352c <rtems_rfs_rtems_fchmod+0x40>      <== ALWAYS TAKEN
 2013514:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    return rtems_rfs_rtems_error ("fchmod: opening inode", rc);       
 2013518:	40 00 35 42 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201351c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2013520:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 2013524:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013528:	81 e8 00 00 	restore                                        <== 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);                    
 201352c:	f8 08 60 02 	ldub  [ %g1 + 2 ], %i4                         
 2013530:	c2 08 60 03 	ldub  [ %g1 + 3 ], %g1                         
 2013534:	b9 2f 20 08 	sll  %i4, 8, %i4                               
                                                                      
  /*                                                                  
   *  Verify I am the owner of the node or the super user.            
   */                                                                 
#if defined (RTEMS_POSIX_API)                                         
  uid = geteuid();                                                    
 2013538:	40 00 0e 1a 	call  2016da0 <geteuid>                        
 201353c:	b8 17 00 01 	or  %i4, %g1, %i4                              
 * @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;          
 2013540:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
 2013544:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 2013548:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
 201354c:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
 2013550:	85 28 a0 08 	sll  %g2, 8, %g2                               
 2013554:	84 10 80 03 	or  %g2, %g3, %g2                              
 2013558:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 201355c:	80 a0 80 08 	cmp  %g2, %o0                                  
 2013560:	02 80 00 0e 	be  2013598 <rtems_rfs_rtems_fchmod+0xac>      <== ALWAYS TAKEN
 2013564:	87 32 20 10 	srl  %o0, 0x10, %g3                            
 2013568:	80 a0 e0 00 	cmp  %g3, 0                                    <== NOT EXECUTED
 201356c:	22 80 00 0c 	be,a   201359c <rtems_rfs_rtems_fchmod+0xb0>   <== NOT EXECUTED
 2013570:	b8 0f 30 00 	and  %i4, -4096, %i4                           <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
 2013574:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 2013578:	7f ff fa 4d 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201357c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);     
 2013580:	40 00 35 28 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2013584:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2013588:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 201358c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2013590:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013594:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
#endif                                                                
                                                                      
  imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
 2013598:	b8 0f 30 00 	and  %i4, -4096, %i4                           
  imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
 201359c:	b2 0e 6f ff 	and  %i1, 0xfff, %i1                           
 20135a0:	b2 17 00 19 	or  %i4, %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);                    
 20135a4:	85 36 60 08 	srl  %i1, 8, %g2                               
 20135a8:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
 20135ac:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  rtems_rfs_inode_set_mode (&inode, imode);                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 20135b0:	90 10 00 1d 	mov  %i5, %o0                                  
 20135b4:	f2 28 60 03 	stb  %i1, [ %g1 + 3 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 20135b8:	82 10 20 01 	mov  1, %g1                                    
 20135bc:	92 07 bf d8 	add  %fp, -40, %o1                             
 20135c0:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
 20135c4:	7f ff fa 3a 	call  2011eac <rtems_rfs_inode_close>          
 20135c8:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
 20135cc:	80 a2 20 00 	cmp  %o0, 0                                    
 20135d0:	04 80 00 05 	ble  20135e4 <rtems_rfs_rtems_fchmod+0xf8>     <== ALWAYS TAKEN
 20135d4:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("fchmod: closing inode", rc);       
 20135d8:	40 00 35 12 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20135dc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20135e0:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 20135e4:	81 c7 e0 08 	ret                                            
 20135e8:	81 e8 00 00 	restore                                        
                                                                      

02013608 <rtems_rfs_rtems_fdatasync>: * @param iop * @return int */ int rtems_rfs_rtems_fdatasync (rtems_libio_t* iop) {
 2013608:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  int rc;                                                             
                                                                      
  rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
 201360c:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  if (rc)                                                             
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
                                                                      
  return 0;                                                           
 2013610:	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));
 2013614:	40 00 20 7d 	call  201b808 <rtems_rfs_buffer_sync>          <== NOT EXECUTED
 2013618:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
  if (rc)                                                             
 201361c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2013620:	02 80 00 05 	be  2013634 <rtems_rfs_rtems_fdatasync+0x2c>   <== NOT EXECUTED
 2013624:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
 2013628:	40 00 34 fe 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201362c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2013630:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
 2013634:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013638:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201f758 <rtems_rfs_rtems_file_close>: * @param iop * @return int */ static int rtems_rfs_rtems_file_close (rtems_libio_t* iop) {
 201f758:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
 201f75c:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
  rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);               
 201f760:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
 201f764:	fa 00 60 98 	ld  [ %g1 + 0x98 ], %i5                        
  int                    rc;                                          
                                                                      
  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);                                          
 201f768:	7f ff ff 20 	call  201f3e8 <rtems_rfs_rtems_lock>           
 201f76c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  rc = rtems_rfs_file_close (fs, file);                               
 201f770:	90 10 00 1d 	mov  %i5, %o0                                  
 201f774:	7f ff f5 7a 	call  201cd5c <rtems_rfs_file_close>           
 201f778:	92 10 00 1c 	mov  %i4, %o1                                  
  if (rc > 0)                                                         
 201f77c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201f780:	04 80 00 06 	ble  201f798 <rtems_rfs_rtems_file_close+0x40> <== ALWAYS TAKEN
 201f784:	01 00 00 00 	nop                                            
    rc = rtems_rfs_rtems_error ("file-close: file close", rc);        
 201f788:	40 00 04 a6 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f78c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201f790:	f0 22 00 00 	st  %i0, [ %o0 ]                               <== NOT EXECUTED
 201f794:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
 201f798:	7f ff ff 29 	call  201f43c <rtems_rfs_rtems_unlock>         
 201f79c:	90 10 00 1d 	mov  %i5, %o0                                  
  return rc;                                                          
}                                                                     
 201f7a0:	81 c7 e0 08 	ret                                            
 201f7a4:	81 e8 00 00 	restore                                        
                                                                      

0201f490 <rtems_rfs_rtems_file_ftruncate>: * @return int */ static int rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop, off_t length) {
 201f490:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
 201f494:	f6 06 20 20 	ld  [ %i0 + 0x20 ], %i3                        
  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));                    
 201f498:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
 201f49c:	7f ff ff d3 	call  201f3e8 <rtems_rfs_rtems_lock>           
 201f4a0:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  rc = rtems_rfs_file_set_size (file, length);                        
 201f4a4:	90 10 00 1b 	mov  %i3, %o0                                  
 201f4a8:	92 10 00 19 	mov  %i1, %o1                                  
 201f4ac:	7f ff f8 4c 	call  201d5dc <rtems_rfs_file_set_size>        
 201f4b0:	94 10 00 1a 	mov  %i2, %o2                                  
  if (rc)                                                             
 201f4b4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201f4b8:	22 80 00 07 	be,a   201f4d4 <rtems_rfs_rtems_file_ftruncate+0x44><== ALWAYS TAKEN
 201f4bc:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
    rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);      
 201f4c0:	40 00 05 58 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f4c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201f4c8:	f0 22 00 00 	st  %i0, [ %o0 ]                               <== NOT EXECUTED
 201f4cc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
 201f4d0:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
 201f4d4:	7f ff ff da 	call  201f43c <rtems_rfs_rtems_unlock>         
 201f4d8:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  return rc;                                                          
}                                                                     
 201f4dc:	81 c7 e0 08 	ret                                            
 201f4e0:	81 e8 00 00 	restore                                        
                                                                      

0201f4e4 <rtems_rfs_rtems_file_lseek>: */ static off_t rtems_rfs_rtems_file_lseek (rtems_libio_t* iop, off_t offset, int whence) {
 201f4e4:	9d e3 bf 98 	save  %sp, -104, %sp                           
 201f4e8:	b8 10 00 19 	mov  %i1, %i4                                  
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
 201f4ec:	f2 06 20 20 	ld  [ %i0 + 0x20 ], %i1                        
 */                                                                   
static off_t                                                          
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,                       
                            off_t          offset,                    
                            int            whence)                    
{                                                                     
 201f4f0:	ba 10 00 1a 	mov  %i2, %i5                                  
  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));                    
 201f4f4:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
 */                                                                   
static off_t                                                          
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,                       
                            off_t          offset,                    
                            int            whence)                    
{                                                                     
 201f4f8:	a0 10 00 1b 	mov  %i3, %l0                                  
  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));                    
 201f4fc:	7f ff ff bb 	call  201f3e8 <rtems_rfs_rtems_lock>           
 201f500:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  old_offset = iop->offset;                                           
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
 201f504:	92 10 00 1c 	mov  %i4, %o1                                  
 201f508:	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;                                           
 201f50c:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
 201f510:	90 10 00 18 	mov  %i0, %o0                                  
 201f514:	40 00 01 26 	call  201f9ac <rtems_filesystem_default_lseek_file>
 201f518:	96 10 00 10 	mov  %l0, %o3                                  
 201f51c:	b8 10 00 08 	mov  %o0, %i4                                  
  if (new_offset != -1)                                               
 201f520:	80 a7 3f ff 	cmp  %i4, -1                                   
 201f524:	12 80 00 05 	bne  201f538 <rtems_rfs_rtems_file_lseek+0x54> 
 201f528:	ba 10 00 09 	mov  %o1, %i5                                  
 201f52c:	80 a2 7f ff 	cmp  %o1, -1                                   
 201f530:	22 80 00 13 	be,a   201f57c <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
 201f534:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
 201f538:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
 201f53c:	90 10 00 19 	mov  %i1, %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;                                  
 201f540:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
 201f544:	92 10 00 02 	mov  %g2, %o1                                  
 201f548:	94 10 00 03 	mov  %g3, %o2                                  
 201f54c:	7f ff f7 e6 	call  201d4e4 <rtems_rfs_file_seek>            
 201f550:	96 07 bf f8 	add  %fp, -8, %o3                              
                                                                      
    if (rc)                                                           
 201f554:	a0 92 20 00 	orcc  %o0, 0, %l0                              
 201f558:	22 80 00 09 	be,a   201f57c <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
 201f55c:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
    {                                                                 
      rtems_rfs_rtems_error ("file_lseek: lseek", rc);                
 201f560:	40 00 05 30 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f564:	39 3f ff ff 	sethi  %hi(0xfffffc00), %i4                    <== NOT EXECUTED
 201f568:	e0 22 00 00 	st  %l0, [ %o0 ]                               <== NOT EXECUTED
      iop->offset = old_offset;                                       
 201f56c:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          <== NOT EXECUTED
      new_offset = -1;                                                
 201f570:	b8 17 23 ff 	or  %i4, 0x3ff, %i4                            <== NOT EXECUTED
 201f574:	ba 10 00 1c 	mov  %i4, %i5                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
 201f578:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        <== NOT EXECUTED
                                                                      
  return new_offset;                                                  
}                                                                     
 201f57c:	b0 10 00 1c 	mov  %i4, %i0                                  
      iop->offset = old_offset;                                       
      new_offset = -1;                                                
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
 201f580:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
 201f584:	7f ff ff ae 	call  201f43c <rtems_rfs_rtems_unlock>         
 201f588:	b2 10 00 1d 	mov  %i5, %i1                                  
                                                                      
  return new_offset;                                                  
}                                                                     
 201f58c:	81 c7 e0 08 	ret                                            
 201f590:	81 e8 00 00 	restore                                        
                                                                      

0201f7a8 <rtems_rfs_rtems_file_open>: static int rtems_rfs_rtems_file_open (rtems_libio_t* iop, const char* pathname, int oflag, mode_t mode) {
 201f7a8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
 201f7ac:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
 201f7b0:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
  if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))        
    printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04i mode:%04" PRIu32 "\n",
           pathname, ino, flags, mode);                               
                                                                      
  rtems_rfs_rtems_lock (fs);                                          
 201f7b4:	7f ff ff 0d 	call  201f3e8 <rtems_rfs_rtems_lock>           
 201f7b8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  ino = rtems_rfs_rtems_get_iop_ino (iop);                            
                                                                      
  rc = rtems_rfs_file_open (fs, ino, flags, &file);                   
 201f7bc:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
 201f7c0:	90 10 00 1d 	mov  %i5, %o0                                  
 201f7c4:	94 10 20 00 	clr  %o2                                       
 201f7c8:	7f ff f8 5d 	call  201d93c <rtems_rfs_file_open>            
 201f7cc:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (rc > 0)                                                         
 201f7d0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 201f7d4:	04 80 00 09 	ble  201f7f8 <rtems_rfs_rtems_file_open+0x50>  <== ALWAYS TAKEN
 201f7d8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
 201f7dc:	7f ff ff 18 	call  201f43c <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f7e0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("file-open: open", rc);             
 201f7e4:	40 00 04 8f 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f7e8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201f7ec:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 201f7f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f7f4:	81 e8 00 00 	restore                                        <== 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);                    
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
 201f7f8:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
                                                                      
  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);                    
 201f7fc:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
 201f800:	7f ff ff 0f 	call  201f43c <rtems_rfs_rtems_unlock>         
 201f804:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
 201f808:	81 c7 e0 08 	ret                                            
 201f80c:	81 e8 00 00 	restore                                        
                                                                      

0201f810 <rtems_rfs_rtems_file_read>: */ static ssize_t rtems_rfs_rtems_file_read (rtems_libio_t* iop, void* buffer, size_t count) {
 201f810:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
 201f814:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        
 */                                                                   
static ssize_t                                                        
rtems_rfs_rtems_file_read (rtems_libio_t* iop,                        
                           void*          buffer,                     
                           size_t         count)                      
{                                                                     
 201f818:	a2 10 00 18 	mov  %i0, %l1                                  
  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));                    
 201f81c:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 201f820:	7f ff fe f2 	call  201f3e8 <rtems_rfs_rtems_lock>           
 201f824:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
 201f828:	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;                                                  
 201f82c:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
 201f830:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201f834:	7f ff ea ec 	call  201a3e4 <rtems_rfs_block_get_size>       
 201f838:	92 02 60 84 	add  %o1, 0x84, %o1                            
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
 201f83c:	80 a2 00 1c 	cmp  %o0, %i4                                  
 201f840:	38 80 00 2b 	bgu,a   201f8ec <rtems_rfs_rtems_file_read+0xdc><== NEVER TAKEN
 201f844:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 201f848:	80 a2 00 1c 	cmp  %o0, %i4                                  
 201f84c:	12 80 00 2e 	bne  201f904 <rtems_rfs_rtems_file_read+0xf4>  <== NEVER TAKEN
 201f850:	b0 10 20 00 	clr  %i0                                       
 201f854:	80 a2 40 1d 	cmp  %o1, %i5                                  
 201f858:	18 80 00 25 	bgu  201f8ec <rtems_rfs_rtems_file_read+0xdc>  
 201f85c:	01 00 00 00 	nop                                            
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (read >= 0)                                                      
    iop->offset = pos + read;                                         
 201f860:	10 80 00 2a 	b  201f908 <rtems_rfs_rtems_file_read+0xf8>    
 201f864:	b6 86 00 1d 	addcc  %i0, %i5, %i3                           
  {                                                                   
    while (count)                                                     
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
 201f868:	92 07 bf fc 	add  %fp, -4, %o1                              
 201f86c:	7f ff f5 e8 	call  201d00c <rtems_rfs_file_io_start>        
 201f870:	94 10 20 01 	mov  1, %o2                                    
      if (rc > 0)                                                     
 201f874:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 201f878:	14 80 00 19 	bg  201f8dc <rtems_rfs_rtems_file_read+0xcc>   <== NEVER TAKEN
 201f87c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
        break;                                                        
      }                                                               
                                                                      
      if (size == 0)                                                  
 201f880:	80 a0 60 00 	cmp  %g1, 0                                    
 201f884:	02 80 00 1d 	be  201f8f8 <rtems_rfs_rtems_file_read+0xe8>   
 201f888:	80 a0 40 1a 	cmp  %g1, %i2                                  
        break;                                                        
                                                                      
      if (size > count)                                               
 201f88c:	38 80 00 02 	bgu,a   201f894 <rtems_rfs_rtems_file_read+0x84>
 201f890:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
        size = count;                                                 
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
 201f894:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
 201f898:	f6 07 bf fc 	ld  [ %fp + -4 ], %i3                          
 201f89c:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
 201f8a0:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
 201f8a4:	94 10 00 1b 	mov  %i3, %o2                                  
 201f8a8:	92 02 40 01 	add  %o1, %g1, %o1                             
 201f8ac:	40 00 08 a9 	call  2021b50 <memcpy>                         
 201f8b0:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
      data  += size;                                                  
      count -= size;                                                  
      read  += size;                                                  
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
 201f8b4:	92 10 00 1b 	mov  %i3, %o1                                  
      if (size > count)                                               
        size = count;                                                 
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
                                                                      
      data  += size;                                                  
 201f8b8:	b2 06 40 1b 	add  %i1, %i3, %i1                             
      count -= size;                                                  
 201f8bc:	b4 26 80 1b 	sub  %i2, %i3, %i2                             
      read  += size;                                                  
 201f8c0:	b0 06 00 1b 	add  %i0, %i3, %i0                             
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
 201f8c4:	90 10 00 10 	mov  %l0, %o0                                  
 201f8c8:	7f ff f6 5a 	call  201d230 <rtems_rfs_file_io_end>          
 201f8cc:	94 10 20 01 	mov  1, %o2                                    
      if (rc > 0)                                                     
 201f8d0:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 201f8d4:	04 80 00 07 	ble  201f8f0 <rtems_rfs_rtems_file_read+0xe0>  <== ALWAYS TAKEN
 201f8d8:	80 a6 a0 00 	cmp  %i2, 0                                    
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-end", rc); 
 201f8dc:	40 00 04 51 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f8e0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201f8e4:	10 80 00 0c 	b  201f914 <rtems_rfs_rtems_file_read+0x104>   <== NOT EXECUTED
 201f8e8:	f6 22 00 00 	st  %i3, [ %o0 ]                               <== NOT EXECUTED
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
  {                                                                   
    while (count)                                                     
 201f8ec:	80 a6 a0 00 	cmp  %i2, 0                                    
 201f8f0:	12 bf ff de 	bne  201f868 <rtems_rfs_rtems_file_read+0x58>  
 201f8f4:	90 10 00 10 	mov  %l0, %o0                                  
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (read >= 0)                                                      
 201f8f8:	80 a6 20 00 	cmp  %i0, 0                                    
 201f8fc:	26 80 00 07 	bl,a   201f918 <rtems_rfs_rtems_file_read+0x108><== NEVER TAKEN
 201f900:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
    iop->offset = pos + read;                                         
 201f904:	b6 86 00 1d 	addcc  %i0, %i5, %i3                           
 201f908:	85 3e 20 1f 	sra  %i0, 0x1f, %g2                            
 201f90c:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
 201f910:	f4 3c 60 08 	std  %i2, [ %l1 + 8 ]                          
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
 201f914:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 201f918:	7f ff fe c9 	call  201f43c <rtems_rfs_rtems_unlock>         
 201f91c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  return read;                                                        
}                                                                     
 201f920:	81 c7 e0 08 	ret                                            
 201f924:	81 e8 00 00 	restore                                        
                                                                      

0201f594 <rtems_rfs_rtems_file_write>: */ static ssize_t rtems_rfs_rtems_file_write (rtems_libio_t* iop, const void* buffer, size_t count) {
 201f594:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
 201f598:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        
 */                                                                   
static ssize_t                                                        
rtems_rfs_rtems_file_write (rtems_libio_t* iop,                       
                            const void*    buffer,                    
                            size_t         count)                     
{                                                                     
 201f59c:	a2 10 00 18 	mov  %i0, %l1                                  
  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));                    
 201f5a0:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 201f5a4:	7f ff ff 91 	call  201f3e8 <rtems_rfs_rtems_lock>           
 201f5a8:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  pos = iop->offset;                                                  
  file_size = rtems_rfs_file_size (file);                             
 201f5ac:	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;                                                  
 201f5b0:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
 201f5b4:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
 201f5b8:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
 201f5bc:	7f ff eb 8a 	call  201a3e4 <rtems_rfs_block_get_size>       
 201f5c0:	92 02 60 84 	add  %o1, 0x84, %o1                            
 201f5c4:	86 10 00 09 	mov  %o1, %g3                                  
  file_size = rtems_rfs_file_size (file);                             
  if (pos > file_size)                                                
 201f5c8:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
 201f5cc:	82 10 00 08 	mov  %o0, %g1                                  
 201f5d0:	80 a2 40 01 	cmp  %o1, %g1                                  
 201f5d4:	18 80 00 08 	bgu  201f5f4 <rtems_rfs_rtems_file_write+0x60> <== NEVER TAKEN
 201f5d8:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
 201f5dc:	80 a2 40 01 	cmp  %o1, %g1                                  
 201f5e0:	12 80 00 11 	bne  201f624 <rtems_rfs_rtems_file_write+0x90> <== NEVER TAKEN
 201f5e4:	80 a0 40 09 	cmp  %g1, %o1                                  
 201f5e8:	80 a2 80 03 	cmp  %o2, %g3                                  
 201f5ec:	08 80 00 0e 	bleu  201f624 <rtems_rfs_rtems_file_write+0x90>
 201f5f0:	80 a0 40 09 	cmp  %g1, %o1                                  
    /*                                                                
     * 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);                         
 201f5f4:	7f ff f7 fa 	call  201d5dc <rtems_rfs_file_set_size>        
 201f5f8:	90 10 00 10 	mov  %l0, %o0                                  
 201f5fc:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
    if (rc)                                                           
 201f600:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201f604:	12 80 00 20 	bne  201f684 <rtems_rfs_rtems_file_write+0xf0> <== NEVER TAKEN
 201f608:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
    {                                                                 
      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);                              
 201f60c:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
 201f610:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
 201f614:	7f ff eb 44 	call  201a324 <rtems_rfs_block_get_bpos>       
 201f618:	96 04 20 10 	add  %l0, 0x10, %o3                            
 */                                                                   
static ssize_t                                                        
rtems_rfs_rtems_file_write (rtems_libio_t* iop,                       
                            const void*    buffer,                    
                            size_t         count)                     
{                                                                     
 201f61c:	10 80 00 40 	b  201f71c <rtems_rfs_rtems_file_write+0x188>  
 201f620:	b0 10 20 00 	clr  %i0                                       
      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) 
 201f624:	38 80 00 09 	bgu,a   201f648 <rtems_rfs_rtems_file_write+0xb4><== NEVER TAKEN
 201f628:	c4 04 60 10 	ld  [ %l1 + 0x10 ], %g2                        <== NOT EXECUTED
 201f62c:	80 a0 40 09 	cmp  %g1, %o1                                  
 201f630:	12 80 00 3b 	bne  201f71c <rtems_rfs_rtems_file_write+0x188><== NEVER TAKEN
 201f634:	b0 10 20 00 	clr  %i0                                       
 201f638:	80 a0 c0 0a 	cmp  %g3, %o2                                  
 201f63c:	08 80 00 39 	bleu  201f720 <rtems_rfs_rtems_file_write+0x18c>
 201f640:	80 a6 a0 00 	cmp  %i2, 0                                    
 201f644:	c4 04 60 10 	ld  [ %l1 + 0x10 ], %g2                        
 201f648:	80 88 a2 00 	btst  0x200, %g2                               
 201f64c:	22 80 00 34 	be,a   201f71c <rtems_rfs_rtems_file_write+0x188>
 201f650:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    pos = file_size;                                                  
 201f654:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
 201f658:	c6 27 bf fc 	st  %g3, [ %fp + -4 ]                          
    rc = rtems_rfs_file_seek (file, pos, &pos);                       
 201f65c:	90 10 00 10 	mov  %l0, %o0                                  
 201f660:	92 10 00 01 	mov  %g1, %o1                                  
 201f664:	94 10 00 03 	mov  %g3, %o2                                  
 201f668:	7f ff f7 9f 	call  201d4e4 <rtems_rfs_file_seek>            
 201f66c:	96 07 bf f8 	add  %fp, -8, %o3                              
    if (rc)                                                           
 201f670:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201f674:	22 80 00 2a 	be,a   201f71c <rtems_rfs_rtems_file_write+0x188><== ALWAYS TAKEN
 201f678:	b0 10 20 00 	clr  %i0                                       
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
 201f67c:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
 201f680:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
 201f684:	7f ff ff 6e 	call  201f43c <rtems_rfs_rtems_unlock>         <== NOT EXECUTED
 201f688:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      return rtems_rfs_rtems_error ("file-write: write append seek", rc);
 201f68c:	40 00 04 e5 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201f690:	01 00 00 00 	nop                                            <== NOT EXECUTED
 201f694:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
 201f698:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201f69c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
 201f6a0:	90 10 00 10 	mov  %l0, %o0                                  
 201f6a4:	92 07 bf f4 	add  %fp, -12, %o1                             
 201f6a8:	7f ff f6 59 	call  201d00c <rtems_rfs_file_io_start>        
 201f6ac:	94 10 20 00 	clr  %o2                                       
    if (rc)                                                           
 201f6b0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201f6b4:	12 80 00 16 	bne  201f70c <rtems_rfs_rtems_file_write+0x178>
 201f6b8:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write open", rc);   
      break;                                                          
    }                                                                 
                                                                      
    if (size > count)                                                 
 201f6bc:	80 a0 40 1a 	cmp  %g1, %i2                                  
 201f6c0:	38 80 00 02 	bgu,a   201f6c8 <rtems_rfs_rtems_file_write+0x134>
 201f6c4:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
 201f6c8:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
 201f6cc:	d4 07 bf f4 	ld  [ %fp + -12 ], %o2                         
 201f6d0:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
 201f6d4:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
 201f6d8:	92 10 00 19 	mov  %i1, %o1                                  
 201f6dc:	40 00 09 1d 	call  2021b50 <memcpy>                         
 201f6e0:	90 02 00 01 	add  %o0, %g1, %o0                             
                                                                      
    data  += size;                                                    
 201f6e4:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
    count -= size;                                                    
    write  += size;                                                   
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
 201f6e8:	90 10 00 10 	mov  %l0, %o0                                  
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
 201f6ec:	b2 06 40 09 	add  %i1, %o1, %i1                             
    count -= size;                                                    
 201f6f0:	b4 26 80 09 	sub  %i2, %o1, %i2                             
    write  += size;                                                   
 201f6f4:	b0 06 00 09 	add  %i0, %o1, %i0                             
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
 201f6f8:	7f ff f6 ce 	call  201d230 <rtems_rfs_file_io_end>          
 201f6fc:	94 10 20 00 	clr  %o2                                       
    if (rc)                                                           
 201f700:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201f704:	02 80 00 07 	be  201f720 <rtems_rfs_rtems_file_write+0x18c> <== ALWAYS TAKEN
 201f708:	80 a6 a0 00 	cmp  %i2, 0                                    
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
 201f70c:	40 00 04 c5 	call  2020a20 <__errno>                        
 201f710:	b0 10 3f ff 	mov  -1, %i0                                   
 201f714:	10 80 00 0c 	b  201f744 <rtems_rfs_rtems_file_write+0x1b0>  
 201f718:	fa 22 00 00 	st  %i5, [ %o0 ]                               
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
      return rtems_rfs_rtems_error ("file-write: write append seek", rc);
    }                                                                 
  }                                                                   
                                                                      
  while (count)                                                       
 201f71c:	80 a6 a0 00 	cmp  %i2, 0                                    
 201f720:	32 bf ff e0 	bne,a   201f6a0 <rtems_rfs_rtems_file_write+0x10c>
 201f724:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
 201f728:	80 a6 20 00 	cmp  %i0, 0                                    
 201f72c:	06 80 00 06 	bl  201f744 <rtems_rfs_rtems_file_write+0x1b0> <== NEVER TAKEN
 201f730:	f8 1f bf f8 	ldd  [ %fp + -8 ], %i4                         
    iop->offset = pos + write;                                        
 201f734:	85 3e 20 1f 	sra  %i0, 0x1f, %g2                            
 201f738:	b6 86 00 1d 	addcc  %i0, %i5, %i3                           
 201f73c:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
 201f740:	f4 3c 60 08 	std  %i2, [ %l1 + 8 ]                          
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
 201f744:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
 201f748:	7f ff ff 3d 	call  201f43c <rtems_rfs_rtems_unlock>         
 201f74c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
                                                                      
  return write;                                                       
}                                                                     
 201f750:	81 c7 e0 08 	ret                                            
 201f754:	81 e8 00 00 	restore                                        
                                                                      

0201324c <rtems_rfs_rtems_fstat>: } int rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc, struct stat* buf) {
 201324c:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
 2013250:	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);                  
 2013254:	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);  
 2013258:	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);                  
 201325c:	94 07 bf d8 	add  %fp, -40, %o2                             
 2013260:	90 10 00 1d 	mov  %i5, %o0                                  
 2013264:	7f ff fa a0 	call  2011ce4 <rtems_rfs_inode_open>           
 2013268:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201326c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2013270:	02 80 00 07 	be  201328c <rtems_rfs_rtems_fstat+0x40>       <== ALWAYS TAKEN
 2013274:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
  {                                                                   
    return rtems_rfs_rtems_error ("stat: opening inode", rc);         
 2013278:	40 00 35 ea 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201327c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2013280:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 2013284:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013288:	81 e8 00 00 	restore                                        <== NOT EXECUTED
 201328c:	c2 08 a0 02 	ldub  [ %g2 + 2 ], %g1                         
 2013290:	f8 08 a0 03 	ldub  [ %g2 + 3 ], %i4                         
  }                                                                   
                                                                      
  mode = rtems_rfs_inode_get_mode (&inode);                           
                                                                      
  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))           
 2013294:	05 3f ff ec 	sethi  %hi(0xffffb000), %g2                    
 2013298:	83 28 60 08 	sll  %g1, 8, %g1                               
 201329c:	b8 10 40 1c 	or  %g1, %i4, %i4                              
 20132a0:	82 08 40 02 	and  %g1, %g2, %g1                             
 20132a4:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
 20132a8:	80 a0 40 02 	cmp  %g1, %g2                                  
 20132ac:	32 80 00 0c 	bne,a   20132dc <rtems_rfs_rtems_fstat+0x90>   <== ALWAYS TAKEN
 20132b0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
  {                                                                   
    buf->st_rdev =                                                    
      rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
 20132b4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 20132b8:	7f ff fc c5 	call  20125cc <rtems_rfs_inode_get_block>      <== NOT EXECUTED
 20132bc:	90 07 bf d8 	add  %fp, -40, %o0                             <== NOT EXECUTED
 20132c0:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 20132c4:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
 20132c8:	7f ff fc c1 	call  20125cc <rtems_rfs_inode_get_block>      <== NOT EXECUTED
 20132cc:	90 07 bf d8 	add  %fp, -40, %o0                             <== NOT EXECUTED
                                                                      
  mode = rtems_rfs_inode_get_mode (&inode);                           
                                                                      
  if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))           
  {                                                                   
    buf->st_rdev =                                                    
 20132d0:	f6 26 60 18 	st  %i3, [ %i1 + 0x18 ]                        <== NOT EXECUTED
 20132d4:	d0 26 60 1c 	st  %o0, [ %i1 + 0x1c ]                        <== NOT EXECUTED
      rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
                                   rtems_rfs_inode_get_block (&inode, 1));
  }                                                                   
                                                                      
  buf->st_dev     = rtems_rfs_fs_device (fs);                         
 20132d8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
 20132dc:	91 2f 20 10 	sll  %i4, 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);                         
 20132e0:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
 20132e4:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
 20132e8:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
 20132ec:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
 20132f0:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 20132f4:	40 00 01 03 	call  2013700 <rtems_rfs_rtems_mode>           
 20132f8:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
 */                                                                   
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);                  
 20132fc:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 2013300:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         
 2013304:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
 2013308:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
  if (links == 0xffff)                                                
 201330c:	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);                  
 2013310:	85 28 a0 08 	sll  %g2, 8, %g2                               
 2013314:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (links == 0xffff)                                                
 2013318:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
 201331c:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
    links = 0;                                                        
 2013320:	86 39 00 03 	xnor  %g4, %g3, %g3                            
 2013324:	80 a0 00 03 	cmp  %g0, %g3                                  
 2013328:	86 60 20 00 	subx  %g0, 0, %g3                              
 201332c:	84 08 80 03 	and  %g2, %g3, %g2                             
  buf->st_nlink   = rtems_rfs_inode_get_links (&inode);               
 2013330:	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;          
 2013334:	c6 08 60 06 	ldub  [ %g1 + 6 ], %g3                         
 2013338:	c4 08 60 07 	ldub  [ %g1 + 7 ], %g2                         
 201333c:	87 28 e0 08 	sll  %g3, 8, %g3                               
 2013340:	82 10 c0 02 	or  %g3, %g2, %g1                              
  buf->st_uid     = rtems_rfs_inode_get_uid (&inode);                 
  buf->st_gid     = rtems_rfs_inode_get_gid (&inode);                 
 2013344:	90 07 bf d8 	add  %fp, -40, %o0                             
 2013348:	7f ff fc 99 	call  20125ac <rtems_rfs_inode_get_gid>        
 201334c:	c2 36 60 12 	sth  %g1, [ %i1 + 0x12 ]                       
                                                                      
  /*                                                                  
   * 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));
 2013350:	d2 07 bf e0 	ld  [ %fp + -32 ], %o1                         
  buf->st_dev     = rtems_rfs_fs_device (fs);                         
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
  buf->st_nlink   = rtems_rfs_inode_get_links (&inode);               
  buf->st_uid     = rtems_rfs_inode_get_uid (&inode);                 
  buf->st_gid     = rtems_rfs_inode_get_gid (&inode);                 
 2013354:	d0 36 60 14 	sth  %o0, [ %i1 + 0x14 ]                       
                                                                      
  /*                                                                  
   * 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));
 2013358:	40 00 29 6b 	call  201d904 <rtems_rfs_file_get_shared>      
 201335c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  if (shared)                                                         
 2013360:	92 92 20 00 	orcc  %o0, 0, %o1                              
 2013364:	02 80 00 17 	be  20133c0 <rtems_rfs_rtems_fstat+0x174>      
 2013368:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
 201336c:	c2 02 60 8c 	ld  [ %o1 + 0x8c ], %g1                        
    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))                                       
 2013370:	c4 06 60 0c 	ld  [ %i1 + 0xc ], %g2                         
   */                                                                 
  shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
                                                                      
  if (shared)                                                         
  {                                                                   
    buf->st_atime   = rtems_rfs_file_shared_get_atime (shared);       
 2013374:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
 2013378:	c2 02 60 90 	ld  [ %o1 + 0x90 ], %g1                        
 201337c:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
 2013380:	c2 02 60 94 	ld  [ %o1 + 0x94 ], %g1                        
 2013384:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
    buf->st_blocks  = rtems_rfs_file_shared_get_block_count (shared); 
 2013388:	c2 02 60 84 	ld  [ %o1 + 0x84 ], %g1                        
 201338c:	c2 26 60 44 	st  %g1, [ %i1 + 0x44 ]                        
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
 2013390:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 2013394:	84 08 80 01 	and  %g2, %g1, %g2                             
 2013398:	03 00 00 28 	sethi  %hi(0xa000), %g1                        
 201339c:	80 a0 80 01 	cmp  %g2, %g1                                  
 20133a0:	12 80 00 04 	bne  20133b0 <rtems_rfs_rtems_fstat+0x164>     <== ALWAYS TAKEN
 20133a4:	90 10 00 1d 	mov  %i5, %o0                                  
      buf->st_size = rtems_rfs_file_shared_get_block_offset (shared); 
 20133a8:	10 80 00 3d 	b  201349c <rtems_rfs_rtems_fstat+0x250>       <== NOT EXECUTED
 20133ac:	c2 12 60 8a 	lduh  [ %o1 + 0x8a ], %g1                      <== NOT EXECUTED
 */                                                                   
static inline rtems_rfs_pos                                           
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,            
                                rtems_rfs_file_shared* shared)        
{                                                                     
  return rtems_rfs_block_get_size (fs, &shared->size);                
 20133b0:	40 00 1c 0d 	call  201a3e4 <rtems_rfs_block_get_size>       
 20133b4:	92 02 60 84 	add  %o1, 0x84, %o1                            
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
      buf->st_size = rtems_rfs_inode_get_block_offset (&inode);       
    else                                                              
      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);           
 20133b8:	10 80 00 3f 	b  20134b4 <rtems_rfs_rtems_fstat+0x268>       
 20133bc:	d0 3e 60 20 	std  %o0, [ %i1 + 0x20 ]                       
 * @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);                   
 20133c0:	c6 08 60 10 	ldub  [ %g1 + 0x10 ], %g3                      
 20133c4:	c4 08 60 11 	ldub  [ %g1 + 0x11 ], %g2                      
 20133c8:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 20133cc:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20133d0:	84 10 c0 02 	or  %g3, %g2, %g2                              
 20133d4:	c6 08 60 13 	ldub  [ %g1 + 0x13 ], %g3                      
 20133d8:	84 10 80 03 	or  %g2, %g3, %g2                              
 20133dc:	c6 08 60 12 	ldub  [ %g1 + 0x12 ], %g3                      
 20133e0:	87 28 e0 08 	sll  %g3, 8, %g3                               
 20133e4:	84 10 80 03 	or  %g2, %g3, %g2                              
    else                                                              
      buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);     
  }                                                                   
  else                                                                
  {                                                                   
    buf->st_atime   = rtems_rfs_inode_get_atime (&inode);             
 20133e8:	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);                   
 20133ec:	c6 08 60 14 	ldub  [ %g1 + 0x14 ], %g3                      
 20133f0:	c4 08 60 15 	ldub  [ %g1 + 0x15 ], %g2                      
 20133f4:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 20133f8:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 20133fc:	84 10 c0 02 	or  %g3, %g2, %g2                              
 2013400:	c6 08 60 17 	ldub  [ %g1 + 0x17 ], %g3                      
 2013404:	84 10 80 03 	or  %g2, %g3, %g2                              
 2013408:	c6 08 60 16 	ldub  [ %g1 + 0x16 ], %g3                      
 201340c:	87 28 e0 08 	sll  %g3, 8, %g3                               
 2013410:	84 10 80 03 	or  %g2, %g3, %g2                              
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
 2013414:	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);                   
 2013418:	c6 08 60 18 	ldub  [ %g1 + 0x18 ], %g3                      
 201341c:	c4 08 60 19 	ldub  [ %g1 + 0x19 ], %g2                      
 2013420:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 2013424:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2013428:	84 10 c0 02 	or  %g3, %g2, %g2                              
 201342c:	c6 08 60 1b 	ldub  [ %g1 + 0x1b ], %g3                      
 2013430:	84 10 80 03 	or  %g2, %g3, %g2                              
 2013434:	c6 08 60 1a 	ldub  [ %g1 + 0x1a ], %g3                      
 2013438:	87 28 e0 08 	sll  %g3, 8, %g3                               
 201343c:	84 10 80 03 	or  %g2, %g3, %g2                              
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
 2013440:	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);             
 2013444:	c6 08 60 0c 	ldub  [ %g1 + 0xc ], %g3                       
 2013448:	c4 08 60 0d 	ldub  [ %g1 + 0xd ], %g2                       
 201344c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
 2013450:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
 2013454:	84 10 c0 02 	or  %g3, %g2, %g2                              
 2013458:	c6 08 60 0f 	ldub  [ %g1 + 0xf ], %g3                       
 201345c:	84 10 80 03 	or  %g2, %g3, %g2                              
 2013460:	c6 08 60 0e 	ldub  [ %g1 + 0xe ], %g3                       
 2013464:	87 28 e0 08 	sll  %g3, 8, %g3                               
 2013468:	84 10 80 03 	or  %g2, %g3, %g2                              
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
 201346c:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
  else                                                                
  {                                                                   
    buf->st_atime   = rtems_rfs_inode_get_atime (&inode);             
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
 2013470:	c4 26 60 44 	st  %g2, [ %i1 + 0x44 ]                        
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
 2013474:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
 2013478:	86 08 c0 02 	and  %g3, %g2, %g3                             
 201347c:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
 2013480:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2013484:	12 80 00 09 	bne  20134a8 <rtems_rfs_rtems_fstat+0x25c>     
 2013488:	90 10 00 1d 	mov  %i5, %o0                                  
 * @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);            
 201348c:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
      buf->st_size = rtems_rfs_inode_get_block_offset (&inode);       
 2013490:	c2 08 60 0b 	ldub  [ %g1 + 0xb ], %g1                       
 2013494:	85 28 a0 08 	sll  %g2, 8, %g2                               
 2013498:	82 10 40 02 	or  %g1, %g2, %g1                              
 201349c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
 20134a0:	10 80 00 05 	b  20134b4 <rtems_rfs_rtems_fstat+0x268>       
 20134a4:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    else                                                              
      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);           
 20134a8:	7f ff fc 29 	call  201254c <rtems_rfs_inode_get_size>       
 20134ac:	92 07 bf d8 	add  %fp, -40, %o1                             
 20134b0:	d0 3e 60 20 	std  %o0, [ %i1 + 0x20 ]                       
  }                                                                   
                                                                      
  buf->st_blksize = rtems_rfs_fs_block_size (fs);                     
 20134b4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 20134b8:	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);                     
 20134bc:	c2 26 60 40 	st  %g1, [ %i1 + 0x40 ]                        
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 20134c0:	92 07 bf d8 	add  %fp, -40, %o1                             
 20134c4:	7f ff fa 7a 	call  2011eac <rtems_rfs_inode_close>          
 20134c8:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
 20134cc:	80 a2 20 00 	cmp  %o0, 0                                    
 20134d0:	04 80 00 05 	ble  20134e4 <rtems_rfs_rtems_fstat+0x298>     <== ALWAYS TAKEN
 20134d4:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("stat: closing inode", rc);         
 20134d8:	40 00 35 52 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20134dc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20134e0:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 20134e4:	81 c7 e0 08 	ret                                            
 20134e8:	81 e8 00 00 	restore                                        
                                                                      

02012d44 <rtems_rfs_rtems_initialise>: */ int rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry, const void* data) {
 2012d44:	9d e3 bf 98 	save  %sp, -104, %sp                           
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
 2012d48:	3b 00 80 cb 	sethi  %hi(0x2032c00), %i5                     
    if (strncmp (options, "hold-bitmaps",                             
 2012d4c:	35 00 80 cb 	sethi  %hi(0x2032c00), %i2                     
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
 2012d50:	21 00 80 cb 	sethi  %hi(0x2032c00), %l0                     
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
 2012d54:	23 00 80 cb 	sethi  %hi(0x2032c00), %l1                     
                            const void*                           data)
{                                                                     
  rtems_rfs_rtems_private* rtems;                                     
  rtems_rfs_file_system*   fs;                                        
  uint32_t                 flags = 0;                                 
  uint32_t                 max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
 2012d58:	b6 10 20 05 	mov  5, %i3                                    
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
                            const void*                           data)
{                                                                     
  rtems_rfs_rtems_private* rtems;                                     
  rtems_rfs_file_system*   fs;                                        
  uint32_t                 flags = 0;                                 
 2012d5c:	b8 10 20 00 	clr  %i4                                       
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
 2012d60:	ba 17 61 18 	or  %i5, 0x118, %i5                            
    if (strncmp (options, "hold-bitmaps",                             
 2012d64:	b4 16 a1 28 	or  %i2, 0x128, %i2                            
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
 2012d68:	a0 14 21 38 	or  %l0, 0x138, %l0                            
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
 2012d6c:	10 80 00 2f 	b  2012e28 <rtems_rfs_rtems_initialise+0xe4>   
 2012d70:	a2 14 61 48 	or  %l1, 0x148, %l1                            
  {                                                                   
    printf ("options=%s\n", options);                                 
 2012d74:	40 00 3c 84 	call  2021f84 <printf>                         <== NOT EXECUTED
 2012d78:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
 2012d7c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 2012d80:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 2012d84:	40 00 41 45 	call  2023298 <strncmp>                        <== NOT EXECUTED
 2012d88:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
 2012d8c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2012d90:	12 80 00 04 	bne  2012da0 <rtems_rfs_rtems_initialise+0x5c> <== NOT EXECUTED
 2012d94:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
 2012d98:	10 80 00 1a 	b  2012e00 <rtems_rfs_rtems_initialise+0xbc>   <== NOT EXECUTED
 2012d9c:	b8 17 20 01 	or  %i4, 1, %i4                                <== NOT EXECUTED
    else if (strncmp (options, "no-local-cache",                      
 2012da0:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 2012da4:	40 00 41 3d 	call  2023298 <strncmp>                        <== NOT EXECUTED
 2012da8:	94 10 20 0e 	mov  0xe, %o2                                  <== NOT EXECUTED
 2012dac:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2012db0:	12 80 00 04 	bne  2012dc0 <rtems_rfs_rtems_initialise+0x7c> <== NOT EXECUTED
 2012db4:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
 2012db8:	10 80 00 12 	b  2012e00 <rtems_rfs_rtems_initialise+0xbc>   <== NOT EXECUTED
 2012dbc:	b8 17 20 02 	or  %i4, 2, %i4                                <== NOT EXECUTED
    else if (strncmp (options, "max-held-bufs",                       
 2012dc0:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
 2012dc4:	40 00 41 35 	call  2023298 <strncmp>                        <== NOT EXECUTED
 2012dc8:	94 10 20 0d 	mov  0xd, %o2                                  <== NOT EXECUTED
 2012dcc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2012dd0:	12 80 00 07 	bne  2012dec <rtems_rfs_rtems_initialise+0xa8> <== NOT EXECUTED
 2012dd4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
                      sizeof ("max-held-bufs") - 1) == 0)             
    {                                                                 
      max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
 2012dd8:	90 06 60 0e 	add  %i1, 0xe, %o0                             <== NOT EXECUTED
 2012ddc:	40 00 42 0e 	call  2023614 <strtoul>                        <== NOT EXECUTED
 2012de0:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 2012de4:	10 80 00 06 	b  2012dfc <rtems_rfs_rtems_initialise+0xb8>   <== NOT EXECUTED
 2012de8:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
    }                                                                 
    else                                                              
      return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
 2012dec:	40 00 37 0d 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012df0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012df4:	10 80 00 18 	b  2012e54 <rtems_rfs_rtems_initialise+0x110>  <== NOT EXECUTED
 2012df8:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
                                                                      
    options = strchr (options, ',');                                  
 2012dfc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
 2012e00:	40 00 3e 8a 	call  2022828 <strchr>                         <== NOT EXECUTED
 2012e04:	92 10 20 2c 	mov  0x2c, %o1                                 <== NOT EXECUTED
    if (options)                                                      
 2012e08:	b2 92 20 00 	orcc  %o0, 0, %i1                              <== NOT EXECUTED
 2012e0c:	02 80 00 0a 	be  2012e34 <rtems_rfs_rtems_initialise+0xf0>  <== NOT EXECUTED
 2012e10:	01 00 00 00 	nop                                            <== NOT EXECUTED
    {                                                                 
      ++options;                                                      
      if (*options == '\0')                                           
 2012e14:	c2 4e 60 01 	ldsb  [ %i1 + 1 ], %g1                         <== NOT EXECUTED
 2012e18:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2012e1c:	02 80 00 06 	be  2012e34 <rtems_rfs_rtems_initialise+0xf0>  <== NOT EXECUTED
 2012e20:	01 00 00 00 	nop                                            <== NOT EXECUTED
      return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
                                                                      
    options = strchr (options, ',');                                  
    if (options)                                                      
    {                                                                 
      ++options;                                                      
 2012e24:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
 2012e28:	80 a6 60 00 	cmp  %i1, 0                                    
 2012e2c:	12 bf ff d2 	bne  2012d74 <rtems_rfs_rtems_initialise+0x30> <== NEVER TAKEN
 2012e30:	92 10 00 19 	mov  %i1, %o1                                  
      if (*options == '\0')                                           
        options = NULL;                                               
    }                                                                 
  }                                                                   
                                                                      
  rtems = malloc (sizeof (rtems_rfs_rtems_private));                  
 2012e34:	7f ff d5 fd 	call  2008628 <malloc>                         
 2012e38:	90 10 20 04 	mov  4, %o0                                    
  if (!rtems)                                                         
 2012e3c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2012e40:	12 80 00 08 	bne  2012e60 <rtems_rfs_rtems_initialise+0x11c><== ALWAYS TAKEN
 2012e44:	01 00 00 00 	nop                                            
    return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);  
 2012e48:	40 00 36 f6 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012e4c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2012e50:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
 2012e54:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2012e58:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012e5c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      
  memset (rtems, 0, sizeof (rtems_rfs_rtems_private));                
                                                                      
  rc = rtems_rfs_mutex_create (&rtems->access);                       
 2012e60:	40 00 30 11 	call  201eea4 <rtems_rfs_mutex_create>         
 2012e64:	c0 27 40 00 	clr  [ %i5 ]                                   
  if (rc > 0)                                                         
 2012e68:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 2012e6c:	14 80 00 09 	bg  2012e90 <rtems_rfs_rtems_initialise+0x14c> <== NEVER TAKEN
 2012e70:	01 00 00 00 	nop                                            
  {                                                                   
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
  }                                                                   
                                                                      
  rc = rtems_rfs_mutex_lock (&rtems->access);                         
 2012e74:	7f ff ff 96 	call  2012ccc <rtems_rfs_mutex_lock.isra.2>    
 2012e78:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (rc > 0)                                                         
 2012e7c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 2012e80:	24 80 00 0b 	ble,a   2012eac <rtems_rfs_rtems_initialise+0x168><== ALWAYS TAKEN
 2012e84:	d0 06 20 38 	ld  [ %i0 + 0x38 ], %o0                        
  {                                                                   
    rtems_rfs_mutex_destroy (&rtems->access);                         
 2012e88:	40 00 30 22 	call  201ef10 <rtems_rfs_mutex_destroy>        <== NOT EXECUTED
 2012e8c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    free (rtems);                                                     
 2012e90:	7f ff d4 55 	call  2007fe4 <free>                           <== NOT EXECUTED
 2012e94:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
 2012e98:	40 00 36 e2 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012e9c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012ea0:	f4 22 00 00 	st  %i2, [ %o0 ]                               <== NOT EXECUTED
 2012ea4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012ea8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
 2012eac:	94 10 00 1c 	mov  %i4, %o2                                  
 2012eb0:	92 10 00 1d 	mov  %i5, %o1                                  
 2012eb4:	96 10 00 1b 	mov  %i3, %o3                                  
 2012eb8:	40 00 2b 75 	call  201dc8c <rtems_rfs_fs_open>              
 2012ebc:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (rc)                                                             
 2012ec0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2012ec4:	02 80 00 09 	be  2012ee8 <rtems_rfs_rtems_initialise+0x1a4> <== ALWAYS TAKEN
 2012ec8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
  {                                                                   
    free (rtems);                                                     
 2012ecc:	7f ff d4 46 	call  2007fe4 <free>                           <== NOT EXECUTED
 2012ed0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: open", rc);            
 2012ed4:	40 00 36 d3 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012ed8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012edc:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 2012ee0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012ee4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  mt_entry->fs_info                          = fs;                    
  mt_entry->ops                              = &rtems_rfs_ops;        
 2012ee8:	03 00 80 cb 	sethi  %hi(0x2032c00), %g1                     
 2012eec:	82 10 61 58 	or  %g1, 0x158, %g1	! 2032d58 <rtems_rfs_ops>  
 2012ef0:	c2 26 20 0c 	st  %g1, [ %i0 + 0xc ]                         
  mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
 2012ef4:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
  {                                                                   
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info                          = fs;                    
 2012ef8:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
  mt_entry->ops                              = &rtems_rfs_ops;        
  mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
 2012efc:	84 10 20 01 	mov  1, %g2                                    
 * 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);            
 2012f00:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
 2012f04:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  mt_entry->mt_fs_root->location.handlers    = &rtems_rfs_rtems_dir_handlers;
 2012f08:	05 00 80 d2 	sethi  %hi(0x2034800), %g2                     
 2012f0c:	84 10 a3 b0 	or  %g2, 0x3b0, %g2	! 2034bb0 <rtems_rfs_rtems_dir_handlers>
  rtems_rfs_buffers_release (fs);                                     
 2012f10:	40 00 22 60 	call  201b890 <rtems_rfs_buffers_release>      
 2012f14:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
  rtems_rfs_mutex_unlock (&rtems->access);                            
 2012f18:	d0 07 40 00 	ld  [ %i5 ], %o0                               
 2012f1c:	7f ff ff 56 	call  2012c74 <rtems_rfs_mutex_unlock.isra.1>  
 2012f20:	b0 10 20 00 	clr  %i0                                       
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return 0;                                                           
}                                                                     
 2012f24:	81 c7 e0 08 	ret                                            
 2012f28:	81 e8 00 00 	restore                                        
                                                                      

020126f0 <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) {
 20126f0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
 20126f4:	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);     
 20126f8:	d6 06 20 08 	ld  [ %i0 + 8 ], %o3                           
 20126fc:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
 2012700:	d8 06 60 08 	ld  [ %i1 + 8 ], %o4                           
 2012704:	92 10 00 1a 	mov  %i2, %o1                                  
 2012708:	94 10 00 1b 	mov  %i3, %o2                                  
 201270c:	9a 10 20 00 	clr  %o5                                       
 2012710:	40 00 2f 86 	call  201e528 <rtems_rfs_link>                 
 2012714:	b0 10 20 00 	clr  %i0                                       
  if (rc)                                                             
 2012718:	80 a2 20 00 	cmp  %o0, 0                                    
 201271c:	02 80 00 05 	be  2012730 <rtems_rfs_rtems_link+0x40>        <== ALWAYS TAKEN
 2012720:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("link: linking", rc);               
 2012724:	40 00 38 bf 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012728:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201272c:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
	}                                                                    
                                                                      
                                                                      
	return 0;                                                            
}                                                                     
 2012730:	81 c7 e0 08 	ret                                            
 2012734:	81 e8 00 00 	restore                                        
                                                                      

0201f3e8 <rtems_rfs_rtems_lock>: /** * Lock the RFS file system. */ static inline void rtems_rfs_rtems_lock (rtems_rfs_file_system* fs) {
 201f3e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  .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                       
};                                                                    
 201f3ec:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %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);
 201f3f0:	92 10 20 00 	clr  %o1                                       
 201f3f4:	d0 00 40 00 	ld  [ %g1 ], %o0                               
 201f3f8:	7f ff b5 8d 	call  200ca2c <rtems_semaphore_obtain>         
 201f3fc:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 201f400:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201f404:	02 80 00 0c 	be  201f434 <rtems_rfs_rtems_lock+0x4c>        <== ALWAYS TAKEN
 201f408:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 201f40c:	7f ff d0 bf 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201f410:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 201f414:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201f418:	02 80 00 07 	be  201f434 <rtems_rfs_rtems_lock+0x4c>        <== NOT EXECUTED
 201f41c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
 201f420:	7f ff a2 55 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201f424:	31 00 80 cb 	sethi  %hi(0x2032c00), %i0                     <== NOT EXECUTED
 201f428:	b0 16 20 f0 	or  %i0, 0xf0, %i0	! 2032cf0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
 201f42c:	40 00 0a d6 	call  2021f84 <printf>                         <== NOT EXECUTED
 201f430:	93 e8 00 08 	restore  %g0, %o0, %o1                         <== NOT EXECUTED
 201f434:	81 c7 e0 08 	ret                                            
 201f438:	81 e8 00 00 	restore                                        
                                                                      

02012a80 <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) {
 2012a80:	9d e3 bf 60 	save  %sp, -160, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (parentloc);
 2012a84:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  rtems_rfs_ino           parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
 2012a88:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  uid_t                   uid;                                        
  gid_t                   gid;                                        
  int                     rc;                                         
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  uid = geteuid ();                                                   
 2012a8c:	40 00 10 c5 	call  2016da0 <geteuid>                        
 2012a90:	e0 00 60 08 	ld  [ %g1 + 8 ], %l0                           
  gid = getegid ();                                                   
 2012a94:	40 00 10 bf 	call  2016d90 <getegid>                        
 2012a98:	a4 10 00 08 	mov  %o0, %l2                                  
 2012a9c:	a2 10 00 08 	mov  %o0, %l1                                  
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, namelen,             
 2012aa0:	40 00 03 15 	call  20136f4 <rtems_rfs_rtems_imode>          
 2012aa4:	90 10 00 1b 	mov  %i3, %o0                                  
 2012aa8:	82 07 bf d4 	add  %fp, -44, %g1                             
 2012aac:	99 2a 20 10 	sll  %o0, 0x10, %o4                            
 2012ab0:	96 10 00 1a 	mov  %i2, %o3                                  
 2012ab4:	a5 2c a0 10 	sll  %l2, 0x10, %l2                            
 2012ab8:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
 2012abc:	a5 34 a0 10 	srl  %l2, 0x10, %l2                            
 2012ac0:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
 2012ac4:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        
 2012ac8:	e2 23 a0 60 	st  %l1, [ %sp + 0x60 ]                        
 2012acc:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
 2012ad0:	90 10 00 10 	mov  %l0, %o0                                  
 2012ad4:	92 10 00 18 	mov  %i0, %o1                                  
 2012ad8:	94 10 00 19 	mov  %i1, %o2                                  
 2012adc:	99 33 20 10 	srl  %o4, 0x10, %o4                            
 2012ae0:	7f ff fd c8 	call  2012200 <rtems_rfs_inode_create>         
 2012ae4:	9a 10 20 01 	mov  1, %o5                                    
                               rtems_rfs_rtems_imode (mode),          
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
 2012ae8:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 2012aec:	14 80 00 09 	bg  2012b10 <rtems_rfs_rtems_mknod+0x90>       
 2012af0:	d2 07 bf d4 	ld  [ %fp + -44 ], %o1                         
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: inode create", rc);         
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
 2012af4:	90 10 00 10 	mov  %l0, %o0                                  
 2012af8:	94 07 bf d8 	add  %fp, -40, %o2                             
 2012afc:	7f ff fc 7a 	call  2011ce4 <rtems_rfs_inode_open>           
 2012b00:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 2012b04:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 2012b08:	04 80 00 07 	ble  2012b24 <rtems_rfs_rtems_mknod+0xa4>      <== ALWAYS TAKEN
 2012b0c:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: inode open", rc);           
 2012b10:	40 00 37 c4 	call  2020a20 <__errno>                        
 2012b14:	b0 10 3f ff 	mov  -1, %i0                                   
 2012b18:	f4 22 00 00 	st  %i2, [ %o0 ]                               
 2012b1c:	81 c7 e0 08 	ret                                            
 2012b20:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  if (S_ISDIR(mode) || S_ISREG(mode))                                 
 2012b24:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
 2012b28:	82 0e c0 01 	and  %i3, %g1, %g1                             
 2012b2c:	80 a0 40 02 	cmp  %g1, %g2                                  
 2012b30:	02 80 00 1c 	be  2012ba0 <rtems_rfs_rtems_mknod+0x120>      
 2012b34:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
 2012b38:	80 a0 40 02 	cmp  %g1, %g2                                  
 2012b3c:	02 80 00 19 	be  2012ba0 <rtems_rfs_rtems_mknod+0x120>      <== ALWAYS TAKEN
 2012b40:	03 00 00 2c 	sethi  %hi(0xb000), %g1                        
  {                                                                   
  }                                                                   
  else if (S_ISCHR (mode) || S_ISBLK (mode))                          
 2012b44:	b6 0e c0 01 	and  %i3, %g1, %i3                             <== NOT EXECUTED
 2012b48:	03 00 00 08 	sethi  %hi(0x2000), %g1                        <== NOT EXECUTED
 2012b4c:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
 2012b50:	12 80 00 0b 	bne  2012b7c <rtems_rfs_rtems_mknod+0xfc>      <== NOT EXECUTED
 2012b54:	90 07 bf d8 	add  %fp, -40, %o0                             <== NOT EXECUTED
  {                                                                   
    int major;                                                        
    int minor;                                                        
    rtems_filesystem_split_dev_t (dev, major, minor);                 
    rtems_rfs_inode_set_block (&inode, 0, major);                     
 2012b58:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 2012b5c:	7f ff fe ac 	call  201260c <rtems_rfs_inode_set_block>      <== NOT EXECUTED
 2012b60:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    rtems_rfs_inode_set_block (&inode, 1, minor);                     
 2012b64:	90 07 bf d8 	add  %fp, -40, %o0                             <== NOT EXECUTED
 2012b68:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 2012b6c:	7f ff fe a8 	call  201260c <rtems_rfs_inode_set_block>      <== NOT EXECUTED
 2012b70:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
    return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);         
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 2012b74:	10 80 00 0c 	b  2012ba4 <rtems_rfs_rtems_mknod+0x124>       <== NOT EXECUTED
 2012b78:	90 10 00 10 	mov  %l0, %o0                                  <== 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);                               
 2012b7c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 2012b80:	7f ff fc cb 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 2012b84:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);         
 2012b88:	40 00 37 a6 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012b8c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012b90:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
 2012b94:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
 2012b98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012b9c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 2012ba0:	90 10 00 10 	mov  %l0, %o0                                  
 2012ba4:	92 07 bf d8 	add  %fp, -40, %o1                             
 2012ba8:	7f ff fc c1 	call  2011eac <rtems_rfs_inode_close>          
 2012bac:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
 2012bb0:	80 a2 20 00 	cmp  %o0, 0                                    
 2012bb4:	04 80 00 05 	ble  2012bc8 <rtems_rfs_rtems_mknod+0x148>     <== ALWAYS TAKEN
 2012bb8:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: closing inode", rc);        
 2012bbc:	40 00 37 99 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012bc0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012bc4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2012bc8:	81 c7 e0 08 	ret                                            
 2012bcc:	81 e8 00 00 	restore                                        
                                                                      

02012fb0 <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) {
 2012fb0:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (pathloc);
 2012fb4:	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);                  
 2012fb8:	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);
 2012fbc:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
  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);                  
 2012fc0:	94 07 bf d8 	add  %fp, -40, %o2                             
 2012fc4:	90 10 00 1d 	mov  %i5, %o0                                  
 2012fc8:	7f ff fb 47 	call  2011ce4 <rtems_rfs_inode_open>           
 2012fcc:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 2012fd0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 2012fd4:	04 80 00 07 	ble  2012ff0 <rtems_rfs_rtems_node_type+0x40>  <== ALWAYS TAKEN
 2012fd8:	01 00 00 00 	nop                                            
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: opening inode", rc);    
 2012fdc:	40 00 36 91 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012fe0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 2012fe4:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 2012fe8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012fec:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  type = rtems_rfs_rtems_node_type_by_inode (&inode);                 
 2012ff0:	7f ff ff cf 	call  2012f2c <rtems_rfs_rtems_node_type_by_inode>
 2012ff4:	90 07 bf d8 	add  %fp, -40, %o0                             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 2012ff8:	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);                 
 2012ffc:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 2013000:	7f ff fb ab 	call  2011eac <rtems_rfs_inode_close>          
 2013004:	90 10 00 1d 	mov  %i5, %o0                                  
  if (rc > 0)                                                         
 2013008:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201300c:	04 80 00 05 	ble  2013020 <rtems_rfs_rtems_node_type+0x70>  <== ALWAYS TAKEN
 2013010:	01 00 00 00 	nop                                            
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: closing inode", rc);    
 2013014:	40 00 36 83 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2013018:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xfdbfffff>   <== NOT EXECUTED
 201301c:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
 2013020:	81 c7 e0 08 	ret                                            
 2013024:	81 e8 00 00 	restore                                        
                                                                      

02012808 <rtems_rfs_rtems_readlink>: static ssize_t rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc, char* buf, size_t bufsize) {
 2012808:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
 201280c:	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);       
 2012810:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
 2012814:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
 2012818:	94 10 00 19 	mov  %i1, %o2                                  
 201281c:	96 10 00 1a 	mov  %i2, %o3                                  
 2012820:	40 00 31 30 	call  201ece0 <rtems_rfs_symlink_read>         
 2012824:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (rc)                                                             
  {                                                                   
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
  }                                                                   
                                                                      
  return (ssize_t) length;                                            
 2012828:	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)                                                             
 201282c:	80 a2 20 00 	cmp  %o0, 0                                    
 2012830:	02 80 00 05 	be  2012844 <rtems_rfs_rtems_readlink+0x3c>    <== ALWAYS TAKEN
 2012834:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
 2012838:	40 00 38 7a 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201283c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012840:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return (ssize_t) length;                                            
}                                                                     
 2012844:	81 c7 e0 08 	ret                                            
 2012848:	81 e8 00 00 	restore                                        
                                                                      

02012738 <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) {
 2012738:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (old_loc); 
 201273c:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        <== 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);      
 2012740:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           <== 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); 
 2012744:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           <== 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);                   
 2012748:	f0 06 60 08 	ld  [ %i1 + 8 ], %i0                           <== 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);
 201274c:	d6 06 a0 08 	ld  [ %i2 + 8 ], %o3                           <== NOT EXECUTED
 2012750:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
                                                                      
  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);                   
  doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);                  
 2012754:	f2 06 60 0c 	ld  [ %i1 + 0xc ], %i1                         <== 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);
 2012758:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201275c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 2012760:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
 2012764:	40 00 2f 71 	call  201e528 <rtems_rfs_link>                 <== NOT EXECUTED
 2012768:	9a 10 20 01 	mov  1, %o5                                    <== NOT EXECUTED
  if (rc)                                                             
 201276c:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
 2012770:	02 80 00 07 	be  201278c <rtems_rfs_rtems_rename+0x54>      <== NOT EXECUTED
 2012774:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("rename: linking", rc);             
 2012778:	40 00 38 aa 	call  2020a20 <__errno>                        <== NOT EXECUTED
 201277c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 2012780:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 2012784:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012788:	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,                   
 201278c:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
 2012790:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
 2012794:	96 10 00 19 	mov  %i1, %o3                                  <== NOT EXECUTED
 2012798:	98 10 20 02 	mov  2, %o4                                    <== NOT EXECUTED
 201279c:	40 00 2f cc 	call  201e6cc <rtems_rfs_unlink>               <== NOT EXECUTED
 20127a0:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                         rtems_rfs_unlink_dir_allowed);               
  if (rc)                                                             
 20127a4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 20127a8:	02 80 00 05 	be  20127bc <rtems_rfs_rtems_rename+0x84>      <== NOT EXECUTED
 20127ac:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("rename: unlinking", rc);           
 20127b0:	40 00 38 9c 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20127b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20127b8:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 20127bc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20127c0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201363c <rtems_rfs_rtems_set_handlers>: */ bool rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc, rtems_rfs_inode_handle* inode) {
 201363c:	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);                    
 2013640:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
  uint16_t mode = rtems_rfs_inode_get_mode (inode);                   
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
 2013644:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
 2013648:	d2 08 60 02 	ldub  [ %g1 + 2 ], %o1                         
 201364c:	c2 08 60 03 	ldub  [ %g1 + 3 ], %g1                         
 2013650:	93 2a 60 08 	sll  %o1, 8, %o1                               
 2013654:	92 12 40 01 	or  %o1, %g1, %o1                              
 2013658:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
 201365c:	82 0a 40 01 	and  %o1, %g1, %g1                             
 2013660:	80 a0 40 02 	cmp  %g1, %g2                                  
 2013664:	12 80 00 05 	bne  2013678 <rtems_rfs_rtems_set_handlers+0x3c>
 2013668:	c0 26 20 10 	clr  [ %i0 + 0x10 ]                            
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
 201366c:	03 00 80 d2 	sethi  %hi(0x2034800), %g1                     
 2013670:	10 80 00 0a 	b  2013698 <rtems_rfs_rtems_set_handlers+0x5c> 
 2013674:	82 10 63 b0 	or  %g1, 0x3b0, %g1	! 2034bb0 <rtems_rfs_rtems_dir_handlers>
  else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))       
 2013678:	07 00 00 2c 	sethi  %hi(0xb000), %g3                        
 201367c:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
 2013680:	86 0a 40 03 	and  %o1, %g3, %g3                             
 2013684:	80 a0 c0 02 	cmp  %g3, %g2                                  
 2013688:	12 80 00 07 	bne  20136a4 <rtems_rfs_rtems_set_handlers+0x68><== ALWAYS TAKEN
 201368c:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
    loc->handlers = rtems_rfs_rtems_handlers (device);                
 2013690:	03 00 80 d2 	sethi  %hi(0x2034800), %g1                     <== NOT EXECUTED
 2013694:	82 10 63 84 	or  %g1, 0x384, %g1	! 2034b84 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
 2013698:	c2 26 20 10 	st  %g1, [ %i0 + 0x10 ]                        
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
 201369c:	10 80 00 13 	b  20136e8 <rtems_rfs_rtems_set_handlers+0xac> 
 20136a0:	b0 10 20 01 	mov  1, %i0                                    
  loc->handlers = NULL;                                               
  if (RTEMS_RFS_S_ISDIR (mode))                                       
    loc->handlers = rtems_rfs_rtems_handlers (dir);                   
  else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))       
    loc->handlers = rtems_rfs_rtems_handlers (device);                
  else if (RTEMS_RFS_S_ISLNK (mode))                                  
 20136a4:	80 a0 40 02 	cmp  %g1, %g2                                  
 20136a8:	12 80 00 05 	bne  20136bc <rtems_rfs_rtems_set_handlers+0x80>
 20136ac:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
 20136b0:	03 00 80 cb 	sethi  %hi(0x2032c00), %g1                     
 20136b4:	10 bf ff f9 	b  2013698 <rtems_rfs_rtems_set_handlers+0x5c> 
 20136b8:	82 10 61 ac 	or  %g1, 0x1ac, %g1	! 2032dac <rtems_rfs_rtems_link_handlers>
  else if (RTEMS_RFS_S_ISREG (mode))                                  
 20136bc:	80 a0 40 02 	cmp  %g1, %g2                                  
 20136c0:	32 80 00 05 	bne,a   20136d4 <rtems_rfs_rtems_set_handlers+0x98><== NEVER TAKEN
 20136c4:	93 2a 60 10 	sll  %o1, 0x10, %o1                            <== NOT EXECUTED
    loc->handlers = rtems_rfs_rtems_handlers (file);                  
 20136c8:	03 00 80 d2 	sethi  %hi(0x2034800), %g1                     
 20136cc:	10 bf ff f3 	b  2013698 <rtems_rfs_rtems_set_handlers+0x5c> 
 20136d0:	82 10 63 dc 	or  %g1, 0x3dc, %g1	! 2034bdc <rtems_rfs_rtems_file_handlers>
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
 20136d4:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 20136d8:	93 32 60 10 	srl  %o1, 0x10, %o1                            <== NOT EXECUTED
 20136dc:	90 12 21 e0 	or  %o0, 0x1e0, %o0                            <== NOT EXECUTED
 20136e0:	40 00 3a 29 	call  2021f84 <printf>                         <== NOT EXECUTED
 20136e4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
 20136e8:	b0 0e 20 01 	and  %i0, 1, %i0                               
 20136ec:	81 c7 e0 08 	ret                                            
 20136f0:	81 e8 00 00 	restore                                        
                                                                      

0201265c <rtems_rfs_rtems_statvfs>: * @return int */ static int rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc, struct statvfs* sb) {
 201265c:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
 2012660:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
 2012664:	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);  
 2012668:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
 201266c:	94 07 bf fc 	add  %fp, -4, %o2                              <== NOT EXECUTED
 2012670:	7f ff fd 3b 	call  2011b5c <rtems_rfs_group_usage>          <== NOT EXECUTED
 2012674:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  sb->f_bsize   = rtems_rfs_fs_block_size (fs);                       
 2012678:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
 201267c:	c2 26 40 00 	st  %g1, [ %i1 ]                               <== NOT EXECUTED
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
 2012680:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
 2012684:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
 2012688:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== 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);                 
 201268c:	c4 26 60 04 	st  %g2, [ %i1 + 4 ]                           <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
 2012690:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
 2012694:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           <== NOT EXECUTED
 2012698:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          <== 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);                     
 201269c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
 20126a0:	82 20 80 01 	sub  %g2, %g1, %g1                             <== 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;                  
 20126a4:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== 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;                  
 20126a8:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        <== NOT EXECUTED
  sb->f_bavail  = sb->f_bfree;                                        
 20126ac:	c2 26 60 1c 	st  %g1, [ %i1 + 0x1c ]                        <== NOT EXECUTED
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
 20126b0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== 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;                  
 20126b4:	c0 26 60 10 	clr  [ %i1 + 0x10 ]                            <== NOT EXECUTED
  sb->f_bavail  = sb->f_bfree;                                        
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
 20126b8:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        <== NOT EXECUTED
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
 20126bc:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
 20126c0:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        <== NOT EXECUTED
  sb->f_favail  = sb->f_ffree;                                        
 20126c4:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
 20126c8:	03 0a 02 48 	sethi  %hi(0x28092000), %g1                    <== NOT EXECUTED
 20126cc:	82 10 60 01 	or  %g1, 1, %g1	! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
 20126d0:	c2 26 60 2c 	st  %g1, [ %i1 + 0x2c ]                        <== NOT EXECUTED
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
 20126d4:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== 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;                                        
 20126d8:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            <== NOT EXECUTED
  sb->f_files   = rtems_rfs_fs_inodes (fs);                           
  sb->f_ffree   = rtems_rfs_fs_inodes (fs) - inodes;                  
  sb->f_favail  = sb->f_ffree;                                        
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
 20126dc:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        <== NOT EXECUTED
  sb->f_namemax = rtems_rfs_fs_max_name (fs);                         
 20126e0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
 20126e4:	c2 26 60 34 	st  %g1, [ %i1 + 0x34 ]                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
 20126e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20126ec:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

0201284c <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) {
 201284c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
 2012850:	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),                    
 2012854:	90 10 00 1b 	mov  %i3, %o0                                  
 2012858:	40 00 42 5e 	call  20231d0 <strlen>                         
 201285c:	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);
 2012860:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  int                    rc;                                          
                                                                      
  rc = rtems_rfs_symlink (fs, node_name, node_name_len,               
 2012864:	40 00 11 4f 	call  2016da0 <geteuid>                        
 2012868:	ba 10 00 08 	mov  %o0, %i5                                  
 201286c:	40 00 11 49 	call  2016d90 <getegid>                        
 2012870:	a0 10 00 08 	mov  %o0, %l0                                  
 2012874:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
 2012878:	91 32 20 10 	srl  %o0, 0x10, %o0                            
 201287c:	f0 23 a0 60 	st  %i0, [ %sp + 0x60 ]                        
 2012880:	d0 23 a0 5c 	st  %o0, [ %sp + 0x5c ]                        
 2012884:	98 10 00 1d 	mov  %i5, %o4                                  
 2012888:	9b 2c 20 10 	sll  %l0, 0x10, %o5                            
 201288c:	90 10 00 1c 	mov  %i4, %o0                                  
 2012890:	92 10 00 19 	mov  %i1, %o1                                  
 2012894:	94 10 00 1a 	mov  %i2, %o2                                  
 2012898:	96 10 00 1b 	mov  %i3, %o3                                  
 201289c:	9b 33 60 10 	srl  %o5, 0x10, %o5                            
 20128a0:	40 00 30 77 	call  201ea7c <rtems_rfs_symlink>              
 20128a4:	b0 10 20 00 	clr  %i0                                       
                          target, strlen (target),                    
                          geteuid(), getegid(), parent);              
  if (rc)                                                             
 20128a8:	80 a2 20 00 	cmp  %o0, 0                                    
 20128ac:	02 80 00 05 	be  20128c0 <rtems_rfs_rtems_symlink+0x74>     <== ALWAYS TAKEN
 20128b0:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("symlink: linking", rc);            
 20128b4:	40 00 38 5b 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20128b8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20128bc:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 20128c0:	81 c7 e0 08 	ret                                            
 20128c4:	81 e8 00 00 	restore                                        
                                                                      

0201f000 <rtems_rfs_rtems_unlock>: /** * Unlock the RFS file system. */ static inline void rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs) {
 201f000:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);            
 201f004:	fa 06 20 80 	ld  [ %i0 + 0x80 ], %i5                        
  rtems_rfs_buffers_release (fs);                                     
 201f008:	7f ff f2 22 	call  201b890 <rtems_rfs_buffers_release>      
 201f00c:	90 10 00 18 	mov  %i0, %o0                                  
 */                                                                   
static inline int                                                     
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)                       
{                                                                     
#if __rtems__                                                         
  rtems_status_code sc = rtems_semaphore_release (*mutex);            
 201f010:	7f ff b6 d0 	call  200cb50 <rtems_semaphore_release>        
 201f014:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
 201f018:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201f01c:	02 80 00 0c 	be  201f04c <rtems_rfs_rtems_unlock+0x4c>      <== ALWAYS TAKEN
 201f020:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
 201f024:	7f ff d1 b9 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201f028:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 201f02c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201f030:	02 80 00 07 	be  201f04c <rtems_rfs_rtems_unlock+0x4c>      <== NOT EXECUTED
 201f034:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
 201f038:	7f ff a3 4f 	call  2007d74 <rtems_status_text>              <== NOT EXECUTED
 201f03c:	31 00 80 cb 	sethi  %hi(0x2032c00), %i0                     <== NOT EXECUTED
 201f040:	b0 16 20 c8 	or  %i0, 0xc8, %i0	! 2032cc8 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
 201f044:	40 00 0b d0 	call  2021f84 <printf>                         <== NOT EXECUTED
 201f048:	93 e8 00 08 	restore  %g0, %o0, %o1                         <== NOT EXECUTED
 201f04c:	81 c7 e0 08 	ret                                            
 201f050:	81 e8 00 00 	restore                                        
                                                                      

020128c8 <rtems_rfs_rtems_utime>: static int rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc, time_t atime, time_t mtime) {
 20128c8:	9d e3 bf 78 	save  %sp, -136, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
 20128cc:	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);                  
 20128d0:	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);  
 20128d4:	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);                  
 20128d8:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
 20128dc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20128e0:	7f ff fd 01 	call  2011ce4 <rtems_rfs_inode_open>           <== NOT EXECUTED
 20128e4:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
 20128e8:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
 20128ec:	02 80 00 07 	be  2012908 <rtems_rfs_rtems_utime+0x40>       <== NOT EXECUTED
 20128f0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("utime: read inode", rc);           
 20128f4:	40 00 38 4b 	call  2020a20 <__errno>                        <== NOT EXECUTED
 20128f8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 20128fc:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
 2012900:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012904:	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);                  
 2012908:	85 36 60 18 	srl  %i1, 0x18, %g2                            <== NOT EXECUTED
 201290c:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       <== NOT EXECUTED
 2012910:	85 36 60 10 	srl  %i1, 0x10, %g2                            <== NOT EXECUTED
 2012914:	c4 28 60 11 	stb  %g2, [ %g1 + 0x11 ]                       <== NOT EXECUTED
 2012918:	85 36 60 08 	srl  %i1, 8, %g2                               <== NOT EXECUTED
 201291c:	c4 28 60 12 	stb  %g2, [ %g1 + 0x12 ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 2012920:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
 2012924:	c4 2f bf e8 	stb  %g2, [ %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);                  
 2012928:	85 36 a0 18 	srl  %i2, 0x18, %g2                            <== NOT EXECUTED
 201292c:	c4 28 60 14 	stb  %g2, [ %g1 + 0x14 ]                       <== NOT EXECUTED
 2012930:	85 36 a0 10 	srl  %i2, 0x10, %g2                            <== NOT EXECUTED
 2012934:	c4 28 60 15 	stb  %g2, [ %g1 + 0x15 ]                       <== NOT EXECUTED
 2012938:	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);                            
 201293c:	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);                  
 2012940:	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);                  
 2012944:	c4 28 60 16 	stb  %g2, [ %g1 + 0x16 ]                       <== NOT EXECUTED
 2012948:	f4 28 60 17 	stb  %i2, [ %g1 + 0x17 ]                       <== NOT EXECUTED
 201294c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 2012950:	7f ff fd 57 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 2012954:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  if (rc)                                                             
 2012958:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201295c:	02 80 00 05 	be  2012970 <rtems_rfs_rtems_utime+0xa8>       <== NOT EXECUTED
 2012960:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("utime: closing inode", rc);        
 2012964:	40 00 38 2f 	call  2020a20 <__errno>                        <== NOT EXECUTED
 2012968:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 201296c:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2012970:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012974:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201b134 <rtems_rfs_scan_chain>: */ static rtems_rfs_buffer* rtems_rfs_scan_chain (rtems_chain_control* chain, uint32_t* count, rtems_rfs_buffer_block block) {
 201b134:	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))                
 201b138:	90 10 20 00 	clr  %o0                                       
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(                         
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Tail( the_chain )->previous;                          
 201b13c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
 201b140:	7f ff e1 72 	call  2013708 <rtems_rfs_trace>                
 201b144:	92 10 20 80 	mov  0x80, %o1                                 
 201b148:	80 8a 20 ff 	btst  0xff, %o0                                
 201b14c:	22 80 00 29 	be,a   201b1f0 <rtems_rfs_scan_chain+0xbc>     <== ALWAYS TAKEN
 201b150:	39 00 80 cd 	sethi  %hi(0x2033400), %i4                     
    printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
 201b154:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 201b158:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b15c:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
 201b160:	40 00 1b 89 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b164:	90 12 22 10 	or  %o0, 0x210, %o0                            <== 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));            
 201b168:	10 80 00 22 	b  201b1f0 <rtems_rfs_scan_chain+0xbc>         <== NOT EXECUTED
 201b16c:	39 00 80 cd 	sethi  %hi(0x2033400), %i4                     <== NOT EXECUTED
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
 201b170:	7f ff e1 66 	call  2013708 <rtems_rfs_trace>                
 201b174:	01 00 00 00 	nop                                            
 201b178:	80 8a 20 ff 	btst  0xff, %o0                                
 201b17c:	22 80 00 06 	be,a   201b194 <rtems_rfs_scan_chain+0x60>     <== ALWAYS TAKEN
 201b180:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
 201b184:	d2 07 60 34 	ld  [ %i5 + 0x34 ], %o1                        <== NOT EXECUTED
 201b188:	40 00 1b 7f 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b18c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
 201b190:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        <== NOT EXECUTED
 201b194:	80 a0 40 1a 	cmp  %g1, %i2                                  
 201b198:	32 80 00 17 	bne,a   201b1f4 <rtems_rfs_scan_chain+0xc0>    
 201b19c:	fa 07 60 04 	ld  [ %i5 + 4 ], %i5                           
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))            
 201b1a0:	90 10 20 00 	clr  %o0                                       
 201b1a4:	7f ff e1 59 	call  2013708 <rtems_rfs_trace>                
 201b1a8:	92 10 20 80 	mov  0x80, %o1                                 
 201b1ac:	80 8a 20 ff 	btst  0xff, %o0                                
 201b1b0:	22 80 00 07 	be,a   201b1cc <rtems_rfs_scan_chain+0x98>     <== ALWAYS TAKEN
 201b1b4:	c2 06 40 00 	ld  [ %i1 ], %g1                               
        printf (": found block=%" PRIuPTR "\n",                       
 201b1b8:	d2 07 60 34 	ld  [ %i5 + 0x34 ], %o1                        <== NOT EXECUTED
 201b1bc:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     <== NOT EXECUTED
 201b1c0:	40 00 1b 71 	call  2021f84 <printf>                         <== NOT EXECUTED
 201b1c4:	90 12 22 48 	or  %o0, 0x248, %o0	! 2033648 <CSWTCH.2+0x168> <== NOT EXECUTED
                ((intptr_t)(buffer->user)));                          
                                                                      
      (*count)--;                                                     
 201b1c8:	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 );                                         
 201b1cc:	90 10 00 1d 	mov  %i5, %o0                                  
 201b1d0:	82 00 7f ff 	add  %g1, -1, %g1                              
      rtems_chain_extract (node);                                     
      rtems_chain_set_off_chain (node);                               
      return buffer;                                                  
 201b1d4:	b0 10 00 1d 	mov  %i5, %i0                                  
 201b1d8:	7f ff f4 10 	call  2018218 <_Chain_Extract>                 
 201b1dc:	c2 26 40 00 	st  %g1, [ %i1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
 201b1e0:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
 201b1e4:	c0 27 40 00 	clr  [ %i5 ]                                   
 201b1e8:	81 c7 e0 08 	ret                                            
 201b1ec:	81 e8 00 00 	restore                                        
  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));            
 201b1f0:	b8 17 22 40 	or  %i4, 0x240, %i4                            
                                                                      
  while (!rtems_chain_is_head (chain, node))                          
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
 201b1f4:	90 10 20 00 	clr  %o0                                       
  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))                          
 201b1f8:	80 a7 40 18 	cmp  %i5, %i0                                  
 201b1fc:	12 bf ff dd 	bne  201b170 <rtems_rfs_scan_chain+0x3c>       
 201b200:	92 10 20 80 	mov  0x80, %o1                                 
      return buffer;                                                  
    }                                                                 
    node = rtems_chain_previous (node);                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
 201b204:	7f ff e1 41 	call  2013708 <rtems_rfs_trace>                
 201b208:	b0 10 20 00 	clr  %i0                                       
 201b20c:	80 8a 20 ff 	btst  0xff, %o0                                
 201b210:	02 bf ff f6 	be  201b1e8 <rtems_rfs_scan_chain+0xb4>        <== ALWAYS TAKEN
 201b214:	11 00 80 cd 	sethi  %hi(0x2033400), %o0                     
    printf (": not found\n");                                         
 201b218:	40 00 1b f3 	call  20221e4 <puts>                           <== NOT EXECUTED
 201b21c:	90 12 22 60 	or  %o0, 0x260, %o0	! 2033660 <CSWTCH.2+0x180> <== NOT EXECUTED
                                                                      
  return NULL;                                                        
}                                                                     
 201b220:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201b224:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02019884 <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,
 2019884:	9d e3 bf 88 	save  %sp, -120, %sp                           
  rtems_rfs_bitmap_element* map_bits;                                 
  int                       map_index;                                
  int                       map_offset;                               
  int                       rc;                                       
                                                                      
  *found = false;                                                     
 2019888:	c0 2e 80 00 	clrb  [ %i2 ]                                  
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
 201988c:	90 10 00 18 	mov  %i0, %o0                                  
 2019890:	7f ff ff e8 	call  2019830 <rtems_rfs_bitmap_load_map>      
 2019894:	92 07 bf fc 	add  %fp, -4, %o1                              
  if (rc > 0)                                                         
 2019898:	80 a2 20 00 	cmp  %o0, 0                                    
 201989c:	14 80 00 98 	bg  2019afc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NEVER TAKEN
 20198a0:	a1 2e e0 0b 	sll  %i3, 0xb, %l0                             
    return rc;                                                        
                                                                      
  /*                                                                  
   * Calculate the bit we are testing plus the end point we search over.
   */                                                                 
  test_bit = *bit;                                                    
 20198a4:	fa 06 40 00 	ld  [ %i1 ], %i5                               
  end_bit  = test_bit + (window * direction);                         
                                                                      
  if (end_bit < 0)                                                    
 20198a8:	a0 84 00 1d 	addcc  %l0, %i5, %l0                           
 20198ac:	2c 80 00 08 	bneg,a   20198cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
 20198b0:	a0 10 20 00 	clr  %l0                                       
    end_bit = 0;                                                      
  else if (end_bit >= control->size)                                  
 20198b4:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
 20198b8:	80 a4 00 01 	cmp  %l0, %g1                                  
 20198bc:	3a 80 00 04 	bcc,a   20198cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
 20198c0:	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];                  
 20198c4:	10 80 00 03 	b  20198d0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
 20198c8:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
 20198cc:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
  map_bits    = &map[map_index];                                      
 20198d0:	e2 07 bf fc 	ld  [ %fp + -4 ], %l1                          
  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);              
 20198d4:	b9 3f 60 05 	sra  %i5, 5, %i4                               
  map_offset    = rtems_rfs_bitmap_map_offset (test_bit);             
  search_index  = rtems_rfs_bitmap_map_index (map_index);             
 20198d8:	a7 3f 60 0a 	sra  %i5, 0xa, %l3                             
    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);             
 20198dc:	a4 0f 60 1f 	and  %i5, 0x1f, %l2                            
  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];                  
 20198e0:	a7 2c e0 02 	sll  %l3, 2, %l3                               
    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);             
  search_offset = rtems_rfs_bitmap_map_offset (map_index);            
 20198e4:	82 0f 20 1f 	and  %i4, 0x1f, %g1                            
                                                                      
  search_bits = &control->search_bits[search_index];                  
 20198e8:	a6 00 80 13 	add  %g2, %l3, %l3                             
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
 20198ec:	ad 2e e0 02 	sll  %i3, 2, %l6                               
  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];                                      
 20198f0:	85 2f 20 02 	sll  %i4, 2, %g2                               
 20198f4:	a8 10 20 1f 	mov  0x1f, %l4                                 
 20198f8:	80 a6 e0 00 	cmp  %i3, 0                                    
 20198fc:	04 80 00 03 	ble  2019908 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x84>
 2019900:	a2 04 40 02 	add  %l1, %g2, %l1                             
 2019904:	a8 10 20 00 	clr  %l4                                       
        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)))            
 2019908:	ab 3e e0 1f 	sra  %i3, 0x1f, %l5                            
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 201990c:	89 2e e0 05 	sll  %i3, 5, %g4                               
        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)))            
 2019910:	aa 25 40 1b 	sub  %l5, %i3, %l5                             
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
 2019914:	ae 10 20 01 	mov  1, %l7                                    
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
 2019918:	87 36 e0 1f 	srl  %i3, 0x1f, %g3                            
            || ((direction > 0) && (test_bit >= end_bit)))            
 201991c:	ab 35 60 1f 	srl  %l5, 0x1f, %l5                            
       */                                                             
      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;
 2019920:	9a 10 20 20 	mov  0x20, %o5                                 
    /*                                                                
     * 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))
 2019924:	d8 04 c0 00 	ld  [ %l3 ], %o4                               
 2019928:	80 a3 20 00 	cmp  %o4, 0                                    
 201992c:	02 80 00 44 	be  2019a3c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8>
 2019930:	80 a6 e0 00 	cmp  %i3, 0                                    
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 2019934:	96 07 00 1b 	add  %i4, %i3, %o3                             
 2019938:	84 10 20 00 	clr  %g2                                       
 201993c:	97 2a e0 05 	sll  %o3, 5, %o3                               
 2019940:	82 20 40 1c 	sub  %g1, %i4, %g1                             
 2019944:	10 80 00 38 	b  2019a24 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
 2019948:	96 02 c0 14 	add  %o3, %l4, %o3                             
    if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
    {                                                                 
      while ((search_offset >= 0)                                     
             && (search_offset < rtems_rfs_bitmap_element_bits ()))   
      {                                                               
        if (!rtems_rfs_bitmap_test (*search_bits, search_offset))     
 201994c:	80 8b c0 0c 	btst  %o7, %o4                                 
 2019950:	12 80 00 1a 	bne  20199b8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x134>
 2019954:	a4 24 80 1d 	sub  %l2, %i5, %l2                             
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 2019958:	10 80 00 1d 	b  20199cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
 201995c:	ba 00 80 0b 	add  %g2, %o3, %i5                             
 */                                                                   
static bool                                                           
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,               
                       rtems_rfs_bitmap_bit     bit)                  
{                                                                     
  return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);                     
 2019960:	95 2d c0 0a 	sll  %l7, %o2, %o2                             
           * 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))       
 2019964:	80 8a 80 09 	btst  %o2, %o1                                 
 2019968:	02 80 00 12 	be  20199b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
 201996c:	80 a7 40 10 	cmp  %i5, %l0                                  
 */                                                                   
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);                    
 2019970:	94 2a 40 0a 	andn  %o1, %o2, %o2                            
                 && (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,                   
 2019974:	80 a2 a0 00 	cmp  %o2, 0                                    
 2019978:	12 80 00 05 	bne  201998c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108>
 201997c:	d4 24 40 00 	st  %o2, [ %l1 ]                               
 */                                                                   
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);                    
 2019980:	c2 04 c0 00 	ld  [ %l3 ], %g1                               
 2019984:	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,    
 2019988:	de 24 c0 00 	st  %o7, [ %l3 ]                               
                                                     1 << search_offset);
              control->free--;                                        
 201998c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
              *bit = test_bit;                                        
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
 2019990:	c4 06 00 00 	ld  [ %i0 ], %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--;                                        
 2019994:	82 00 7f ff 	add  %g1, -1, %g1                              
 2019998:	c2 26 20 10 	st  %g1, [ %i0 + 0x10 ]                        
              *bit = test_bit;                                        
 201999c:	fa 26 40 00 	st  %i5, [ %i1 ]                               
              *found = true;                                          
 20199a0:	82 10 20 01 	mov  1, %g1                                    
 20199a4:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
              rtems_rfs_buffer_mark_dirty (control->buffer);          
 20199a8:	10 80 00 54 	b  2019af8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
 20199ac:	c2 28 80 00 	stb  %g1, [ %g2 ]                              
              return 0;                                               
            }                                                         
                                                                      
            if (test_bit == end_bit)                                  
 20199b0:	02 80 00 06 	be  20199c8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
 20199b4:	ba 07 40 1b 	add  %i5, %i3, %i5                             
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 20199b8:	94 04 80 1d 	add  %l2, %i5, %o2                             
        {                                                             
          /*                                                          
           * 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)                                    
 20199bc:	80 a2 a0 1f 	cmp  %o2, 0x1f                                 
 20199c0:	28 bf ff e8 	bleu,a   2019960 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xdc><== ALWAYS TAKEN
 20199c4:	d2 04 40 00 	ld  [ %l1 ], %o1                               
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 20199c8:	ba 00 80 0b 	add  %g2, %o3, %i5                             
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
 20199cc:	a2 04 40 16 	add  %l1, %l6, %l1                             
        map_index += direction;                                       
 20199d0:	b8 07 00 1b 	add  %i4, %i3, %i4                             
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
                                                                      
        search_offset += direction;                                   
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
 20199d4:	80 a7 40 10 	cmp  %i5, %l0                                  
 20199d8:	04 80 00 03 	ble  20199e4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x160>
 20199dc:	9e 10 20 01 	mov  1, %o7                                    
 20199e0:	9e 10 20 00 	clr  %o7                                       
 20199e4:	80 8b e0 ff 	btst  0xff, %o7                                
 20199e8:	02 80 00 05 	be  20199fc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178>
 20199ec:	84 00 80 04 	add  %g2, %g4, %g2                             
 20199f0:	80 a0 e0 00 	cmp  %g3, 0                                    
 20199f4:	32 80 00 29 	bne,a   2019a98 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x214>
 20199f8:	a4 10 00 14 	mov  %l4, %l2                                  
            || ((direction > 0) && (test_bit >= end_bit)))            
 20199fc:	80 a7 40 10 	cmp  %i5, %l0                                  
 2019a00:	16 80 00 03 	bge  2019a0c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188>
 2019a04:	9e 10 20 01 	mov  1, %o7                                    
 2019a08:	9e 10 20 00 	clr  %o7                                       
 2019a0c:	80 8b e0 ff 	btst  0xff, %o7                                
 2019a10:	02 80 00 05 	be  2019a24 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
 2019a14:	a4 10 00 14 	mov  %l4, %l2                                  
 2019a18:	80 a5 60 00 	cmp  %l5, 0                                    
 2019a1c:	32 80 00 20 	bne,a   2019a9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
 2019a20:	a6 04 c0 16 	add  %l3, %l6, %l3                             
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
 2019a24:	9e 00 40 1c 	add  %g1, %i4, %o7                             
     * 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)                                     
 2019a28:	80 a3 e0 1f 	cmp  %o7, 0x1f                                 
 2019a2c:	28 bf ff c8 	bleu,a   201994c <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc8>
 2019a30:	9f 2d c0 0f 	sll  %l7, %o7, %o7                             
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
 2019a34:	10 80 00 1a 	b  2019a9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
 2019a38:	a6 04 c0 16 	add  %l3, %l6, %l3                             
       * 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)                                              
 2019a3c:	04 80 00 07 	ble  2019a58 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4>
 2019a40:	ba 0f 7f e0 	and  %i5, -32, %i5                             
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
 2019a44:	92 23 40 01 	sub  %o5, %g1, %o1                             
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
        map_offset = 0;                                               
 2019a48:	a4 10 20 00 	clr  %l2                                       
      rtems_rfs_bitmap_bit bits_skipped;                              
      test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);       
      if (direction > 0)                                              
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
 2019a4c:	83 2a 60 05 	sll  %o1, 5, %g1                               
 2019a50:	10 80 00 07 	b  2019a6c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8>
 2019a54:	ba 00 40 1d 	add  %g1, %i5, %i5                             
        map_offset = 0;                                               
      }                                                               
      else                                                            
      {                                                               
        bits_skipped = search_offset + 1;                             
 2019a58:	92 00 60 01 	add  %g1, 1, %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;
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
 2019a5c:	a4 10 20 1f 	mov  0x1f, %l2                                 
        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;
 2019a60:	83 28 60 05 	sll  %g1, 5, %g1                               
 2019a64:	82 38 00 01 	xnor  %g0, %g1, %g1                            
 2019a68:	ba 00 40 1d 	add  %g1, %i5, %i5                             
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
      }                                                               
      map_bits += direction * bits_skipped;                           
 2019a6c:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
 2019a70:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
 2019a74:	da 27 bf ec 	st  %o5, [ %fp + -20 ]                         
 2019a78:	7f ff a2 c7 	call  2002594 <.umul>                          
 2019a7c:	90 10 00 1b 	mov  %i3, %o0                                  
 2019a80:	c6 07 bf f4 	ld  [ %fp + -12 ], %g3                         
 2019a84:	83 2a 20 02 	sll  %o0, 2, %g1                               
      map_index += direction * bits_skipped;                          
 2019a88:	b8 07 00 08 	add  %i4, %o0, %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;                           
 2019a8c:	a2 04 40 01 	add  %l1, %g1, %l1                             
 2019a90:	c8 07 bf f0 	ld  [ %fp + -16 ], %g4                         
 2019a94:	da 07 bf ec 	ld  [ %fp + -20 ], %o5                         
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
 2019a98:	a6 04 c0 16 	add  %l3, %l6, %l3                             
    search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
 2019a9c:	80 a6 e0 00 	cmp  %i3, 0                                    
 2019aa0:	04 80 00 03 	ble  2019aac <rtems_rfs_search_map_for_clear_bit.constprop.1+0x228>
 2019aa4:	82 10 20 1f 	mov  0x1f, %g1                                 
 2019aa8:	82 10 20 00 	clr  %g1                                       
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
 2019aac:	80 a7 40 10 	cmp  %i5, %l0                                  
 2019ab0:	16 80 00 03 	bge  2019abc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x238>
 2019ab4:	84 10 20 01 	mov  1, %g2                                    
 2019ab8:	84 10 20 00 	clr  %g2                                       
         || ((direction > 0) && (test_bit <= end_bit)));              
 2019abc:	80 88 a0 ff 	btst  0xff, %g2                                
 2019ac0:	02 80 00 06 	be  2019ad8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x254>
 2019ac4:	80 a7 40 10 	cmp  %i5, %l0                                  
 2019ac8:	80 a0 e0 00 	cmp  %g3, 0                                    
 2019acc:	32 bf ff 97 	bne,a   2019928 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
 2019ad0:	d8 04 c0 00 	ld  [ %l3 ], %o4                               
 2019ad4:	80 a7 40 10 	cmp  %i5, %l0                                  
 2019ad8:	04 80 00 03 	ble  2019ae4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x260>
 2019adc:	84 10 20 01 	mov  1, %g2                                    
 2019ae0:	84 10 20 00 	clr  %g2                                       
 2019ae4:	80 88 a0 ff 	btst  0xff, %g2                                
 2019ae8:	02 80 00 04 	be  2019af8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
 2019aec:	80 a5 60 00 	cmp  %l5, 0                                    
 2019af0:	32 bf ff 8e 	bne,a   2019928 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4>
 2019af4:	d8 04 c0 00 	ld  [ %l3 ], %o4                               
                                                                      
  return 0;                                                           
 2019af8:	90 10 20 00 	clr  %o0                                       
}                                                                     
 2019afc:	81 c7 e0 08 	ret                                            
 2019b00:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0201ea7c <rtems_rfs_symlink>: const char* link, int link_length, uid_t uid, gid_t gid, rtems_rfs_ino parent) {
 201ea7c:	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))                      
 201ea80:	90 10 20 02 	mov  2, %o0                                    
                   const char*            link,                       
                   int                    link_length,                
                   uid_t                  uid,                        
                   gid_t                  gid,                        
                   rtems_rfs_ino          parent)                     
{                                                                     
 201ea84:	e2 07 a0 60 	ld  [ %fp + 0x60 ], %l1                        
 201ea88:	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))                      
 201ea8c:	7f ff d3 1f 	call  2013708 <rtems_rfs_trace>                
 201ea90:	92 10 20 00 	clr  %o1                                       
 201ea94:	80 8a 20 ff 	btst  0xff, %o0                                
 201ea98:	12 80 00 07 	bne  201eab4 <rtems_rfs_symlink+0x38>          <== NEVER TAKEN
 201ea9c:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     
    printf (" link:");                                                
    for (c = 0; c < link_length; c++)                                 
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
 201eaa0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 201eaa4:	80 a7 00 01 	cmp  %i4, %g1                                  
 201eaa8:	1a 80 00 8b 	bcc  201ecd4 <rtems_rfs_symlink+0x258>         <== NEVER TAKEN
 201eaac:	b4 10 20 5b 	mov  0x5b, %i2                                 
 201eab0:	30 80 00 19 	b,a   201eb14 <rtems_rfs_symlink+0x98>         
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))                      
  {                                                                   
    int c;                                                            
    printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);  
 201eab4:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
 201eab8:	90 12 22 e0 	or  %o0, 0x2e0, %o0                            <== NOT EXECUTED
 201eabc:	40 00 0d 32 	call  2021f84 <printf>                         <== NOT EXECUTED
 201eac0:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
 201eac4:	10 80 00 05 	b  201ead8 <rtems_rfs_symlink+0x5c>            <== NOT EXECUTED
 201eac8:	80 a4 00 1a 	cmp  %l0, %i2                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
 201eacc:	40 00 0d 98 	call  202212c <putchar>                        <== NOT EXECUTED
 201ead0:	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++)                                      
 201ead4:	80 a4 00 1a 	cmp  %l0, %i2                                  <== NOT EXECUTED
 201ead8:	26 bf ff fd 	bl,a   201eacc <rtems_rfs_symlink+0x50>        <== NOT EXECUTED
 201eadc:	d0 4e 40 10 	ldsb  [ %i1 + %l0 ], %o0                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (" link:");                                                
 201eae0:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
    for (c = 0; c < link_length; c++)                                 
 201eae4:	b4 10 20 00 	clr  %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:");                                                
 201eae8:	40 00 0d 27 	call  2021f84 <printf>                         <== NOT EXECUTED
 201eaec:	90 12 23 08 	or  %o0, 0x308, %o0                            <== NOT EXECUTED
    for (c = 0; c < link_length; c++)                                 
 201eaf0:	10 80 00 05 	b  201eb04 <rtems_rfs_symlink+0x88>            <== NOT EXECUTED
 201eaf4:	80 a6 80 1c 	cmp  %i2, %i4                                  <== NOT EXECUTED
      printf ("%c", link[c]);                                         
 201eaf8:	40 00 0d 8d 	call  202212c <putchar>                        <== NOT EXECUTED
 201eafc:	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++)                                 
 201eb00:	80 a6 80 1c 	cmp  %i2, %i4                                  <== NOT EXECUTED
 201eb04:	26 bf ff fd 	bl,a   201eaf8 <rtems_rfs_symlink+0x7c>        <== NOT EXECUTED
 201eb08:	d0 4e c0 1a 	ldsb  [ %i3 + %i2 ], %o0                       <== NOT EXECUTED
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
 201eb0c:	10 bf ff e6 	b  201eaa4 <rtems_rfs_symlink+0x28>            <== NOT EXECUTED
 201eb10:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           <== NOT EXECUTED
    return ENAMETOOLONG;                                              
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),       
 201eb14:	40 00 11 af 	call  20231d0 <strlen>                         
 201eb18:	90 10 00 19 	mov  %i1, %o0                                  
 201eb1c:	82 07 bf 74 	add  %fp, -140, %g1                            
 201eb20:	96 10 00 08 	mov  %o0, %o3                                  
 201eb24:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
 201eb28:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
 201eb2c:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
 201eb30:	90 10 00 18 	mov  %i0, %o0                                  
 201eb34:	92 10 00 11 	mov  %l1, %o1                                  
 201eb38:	94 10 00 19 	mov  %i1, %o2                                  
 201eb3c:	19 00 00 28 	sethi  %hi(0xa000), %o4                        
 201eb40:	9a 10 20 01 	mov  1, %o5                                    
 201eb44:	7f ff cd af 	call  2012200 <rtems_rfs_inode_create>         
 201eb48:	98 13 21 ff 	or  %o4, 0x1ff, %o4                            
                               RTEMS_RFS_S_SYMLINK,                   
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
 201eb4c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 201eb50:	34 80 00 62 	bg,a   201ecd8 <rtems_rfs_symlink+0x25c>       <== NEVER TAKEN
 201eb54:	b0 10 00 1a 	mov  %i2, %i0                                  <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
 201eb58:	d2 07 bf 74 	ld  [ %fp + -140 ], %o1                        
 201eb5c:	90 10 00 18 	mov  %i0, %o0                                  
 201eb60:	94 07 bf 88 	add  %fp, -120, %o2                            
 201eb64:	7f ff cc 60 	call  2011ce4 <rtems_rfs_inode_open>           
 201eb68:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
 201eb6c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
 201eb70:	34 80 00 5a 	bg,a   201ecd8 <rtems_rfs_symlink+0x25c>       <== NEVER TAKEN
 201eb74:	b0 10 00 1a 	mov  %i2, %i0                                  <== NOT EXECUTED
  /*                                                                  
   * If the link length is less than the length of data union in the inode
   * place the link into the data area else allocate a block and write the link
   * to that.                                                         
   */                                                                 
  if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)                   
 201eb78:	80 a7 20 13 	cmp  %i4, 0x13                                 
 201eb7c:	38 80 00 15 	bgu,a   201ebd0 <rtems_rfs_symlink+0x154>      <== NEVER TAKEN
 201eb80:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  {                                                                   
    memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
 201eb84:	d0 07 bf 94 	ld  [ %fp + -108 ], %o0                        
 201eb88:	92 10 20 00 	clr  %o1                                       
 201eb8c:	94 10 20 14 	mov  0x14, %o2                                 
 201eb90:	40 00 0c 7f 	call  2021d8c <memset>                         
 201eb94:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
    memcpy (inode.node->data.name, link, link_length);                
 201eb98:	d0 07 bf 94 	ld  [ %fp + -108 ], %o0                        
 201eb9c:	92 10 00 1b 	mov  %i3, %o1                                  
 201eba0:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
 201eba4:	40 00 0b eb 	call  2021b50 <memcpy>                         
 201eba8:	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);      
 201ebac:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 201ebb0:	c0 28 60 0c 	clrb  [ %g1 + 0xc ]                            
 201ebb4:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 201ebb8:	c0 28 60 0d 	clrb  [ %g1 + 0xd ]                            
 201ebbc:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 201ebc0:	c0 28 60 0e 	clrb  [ %g1 + 0xe ]                            
 201ebc4:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 201ebc8:	10 80 00 38 	b  201eca8 <rtems_rfs_symlink+0x22c>           
 201ebcc:	c0 28 60 0f 	clrb  [ %g1 + 0xf ]                            
    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);                 
 201ebd0:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
 201ebd4:	7f ff ee 1c 	call  201a444 <rtems_rfs_block_map_open>       <== NOT EXECUTED
 201ebd8:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
 201ebdc:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
    if (rc > 0)                                                       
 201ebe0:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
 201ebe4:	14 80 00 2d 	bg  201ec98 <rtems_rfs_symlink+0x21c>          <== NOT EXECUTED
 201ebe8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);              
 201ebec:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
 201ebf0:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 201ebf4:	7f ff ef 6f 	call  201a9b0 <rtems_rfs_block_map_grow>       <== NOT EXECUTED
 201ebf8:	96 07 bf 78 	add  %fp, -136, %o3                            <== NOT EXECUTED
    if (rc > 0)                                                       
 201ebfc:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
 201ec00:	14 80 00 0c 	bg  201ec30 <rtems_rfs_symlink+0x1b4>          <== NOT EXECUTED
 201ec04:	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_buffer_handle_request (fs, &buffer, block, false); 
 201ec08:	d4 07 bf 78 	ld  [ %fp + -136 ], %o2                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201ec0c:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201ec10:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201ec14:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
 201ec18:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
 201ec1c:	7f ff f1 f7 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201ec20:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
    if (rc > 0)                                                       
 201ec24:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
 201ec28:	04 80 00 06 	ble  201ec40 <rtems_rfs_symlink+0x1c4>         <== NOT EXECUTED
 201ec2c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
 201ec30:	7f ff ee 66 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201ec34:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_close (fs, &map);                        
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
 201ec38:	10 80 00 18 	b  201ec98 <rtems_rfs_symlink+0x21c>           <== NOT EXECUTED
 201ec3c:	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);                           
 201ec40:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
 201ec44:	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);                           
 201ec48:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
 201ec4c:	92 10 20 ff 	mov  0xff, %o1                                 <== NOT EXECUTED
 201ec50:	40 00 0c 4f 	call  2021d8c <memset>                         <== NOT EXECUTED
 201ec54:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    memcpy (data, link, link_length);                                 
 201ec58:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
 201ec5c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
 201ec60:	40 00 0b bc 	call  2021b50 <memcpy>                         <== NOT EXECUTED
 201ec64:	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);                       
 201ec68:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
 201ec6c:	7f ff f1 6f 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201ec70:	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);                        
 201ec74:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
 201ec78:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201ec7c:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201ec80:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
 201ec84:	7f ff ee 51 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201ec88:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
 201ec8c:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
 201ec90:	04 80 00 06 	ble  201eca8 <rtems_rfs_symlink+0x22c>         <== NOT EXECUTED
 201ec94:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
 201ec98:	7f ff cc 85 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201ec9c:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
  rtems_rfs_inode_set_block_offset (&inode, link_length);             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
                                                                      
  return rc;                                                          
}                                                                     
 201eca0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201eca4:	91 e8 00 1a 	restore  %g0, %i2, %o0                         <== NOT EXECUTED
 */                                                                   
static inline void                                                    
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,     
                                  uint16_t                block_offset)
{                                                                     
  rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);    
 201eca8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
 201ecac:	85 37 20 08 	srl  %i4, 8, %g2                               
 201ecb0:	c4 28 60 0a 	stb  %g2, [ %g1 + 0xa ]                        
 201ecb4:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_inode_set_block_offset (&inode, link_length);             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 201ecb8:	90 10 00 18 	mov  %i0, %o0                                  
 201ecbc:	f8 28 60 0b 	stb  %i4, [ %g1 + 0xb ]                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201ecc0:	82 10 20 01 	mov  1, %g1                                    
 201ecc4:	92 07 bf 88 	add  %fp, -120, %o1                            
 201ecc8:	7f ff cc 79 	call  2011eac <rtems_rfs_inode_close>          
 201eccc:	c2 2f bf 98 	stb  %g1, [ %fp + -104 ]                       
 201ecd0:	b4 10 00 08 	mov  %o0, %i2                                  
                                                                      
  return rc;                                                          
}                                                                     
 201ecd4:	b0 10 00 1a 	mov  %i2, %i0                                  
 201ecd8:	81 c7 e0 08 	ret                                            
 201ecdc:	81 e8 00 00 	restore                                        
                                                                      

0201ece0 <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) {
 201ece0:	9d e3 bf 18 	save  %sp, -232, %sp                           
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
 201ece4:	90 10 20 04 	mov  4, %o0                                    
 201ece8:	92 10 20 00 	clr  %o1                                       
 201ecec:	7f ff d2 87 	call  2013708 <rtems_rfs_trace>                
 201ecf0:	ba 10 00 18 	mov  %i0, %i5                                  
 201ecf4:	80 8a 20 ff 	btst  0xff, %o0                                
 201ecf8:	22 80 00 07 	be,a   201ed14 <rtems_rfs_symlink_read+0x34>   <== ALWAYS TAKEN
 201ecfc:	90 10 00 1d 	mov  %i5, %o0                                  
    printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);     
 201ed00:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201ed04:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201ed08:	40 00 0c 9f 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ed0c:	90 12 23 10 	or  %o0, 0x310, %o0                            <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
 201ed10:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ed14:	92 10 00 19 	mov  %i1, %o1                                  
 201ed18:	94 07 bf 88 	add  %fp, -120, %o2                            
 201ed1c:	7f ff cb f2 	call  2011ce4 <rtems_rfs_inode_open>           
 201ed20:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201ed24:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 201ed28:	12 80 00 0d 	bne  201ed5c <rtems_rfs_symlink_read+0x7c>     <== NEVER TAKEN
 201ed2c:	d2 07 bf 94 	ld  [ %fp + -108 ], %o1                        
    return rc;                                                        
                                                                      
  if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))         
 201ed30:	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);                    
 201ed34:	c4 0a 60 02 	ldub  [ %o1 + 2 ], %g2                         
 201ed38:	85 28 a0 08 	sll  %g2, 8, %g2                               
 201ed3c:	84 08 80 01 	and  %g2, %g1, %g2                             
 201ed40:	03 00 00 28 	sethi  %hi(0xa000), %g1                        
 201ed44:	80 a0 80 01 	cmp  %g2, %g1                                  
 201ed48:	02 80 00 07 	be  201ed64 <rtems_rfs_symlink_read+0x84>      <== ALWAYS TAKEN
 201ed4c:	90 10 00 1d 	mov  %i5, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
 201ed50:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
 201ed54:	7f ff cc 56 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201ed58:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
 201ed5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201ed60:	81 e8 00 00 	restore                                        <== 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);            
 201ed64:	d4 0a 60 0a 	ldub  [ %o1 + 0xa ], %o2                       
    return EINVAL;                                                    
  }                                                                   
                                                                      
  *length = rtems_rfs_inode_get_block_offset (&inode);                
 201ed68:	c2 0a 60 0b 	ldub  [ %o1 + 0xb ], %g1                       
 201ed6c:	95 2a a0 08 	sll  %o2, 8, %o2                               
 201ed70:	94 10 40 0a 	or  %g1, %o2, %o2                              
 201ed74:	80 a2 80 1b 	cmp  %o2, %i3                                  
 201ed78:	38 80 00 02 	bgu,a   201ed80 <rtems_rfs_symlink_read+0xa0>  
 201ed7c:	94 10 00 1b 	mov  %i3, %o2                                  
 201ed80:	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);             
 201ed84:	c2 0a 60 0d 	ldub  [ %o1 + 0xd ], %g1                       
 201ed88:	c4 0a 60 0c 	ldub  [ %o1 + 0xc ], %g2                       
 201ed8c:	83 28 60 10 	sll  %g1, 0x10, %g1                            
 201ed90:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
 201ed94:	84 10 80 01 	or  %g2, %g1, %g2                              
 201ed98:	c2 0a 60 0f 	ldub  [ %o1 + 0xf ], %g1                       
 201ed9c:	84 10 80 01 	or  %g2, %g1, %g2                              
 201eda0:	c2 0a 60 0e 	ldub  [ %o1 + 0xe ], %g1                       
 201eda4:	83 28 60 08 	sll  %g1, 8, %g1                               
  if (size < *length)                                                 
  {                                                                   
    *length = size;                                                   
  }                                                                   
                                                                      
  if (rtems_rfs_inode_get_block_count (&inode) == 0)                  
 201eda8:	80 90 80 01 	orcc  %g2, %g1, %g0                            
 201edac:	32 80 00 07 	bne,a   201edc8 <rtems_rfs_symlink_read+0xe8>  <== NEVER TAKEN
 201edb0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    memcpy (path, inode.node->data.name, *length);                    
 201edb4:	90 10 00 1a 	mov  %i2, %o0                                  
 201edb8:	40 00 0b 66 	call  2021b50 <memcpy>                         
 201edbc:	92 02 60 1c 	add  %o1, 0x1c, %o1                            
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 201edc0:	10 80 00 34 	b  201ee90 <rtems_rfs_symlink_read+0x1b0>      
 201edc4:	90 10 00 1d 	mov  %i5, %o0                                  
    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);                 
 201edc8:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
 201edcc:	7f ff ed 9e 	call  201a444 <rtems_rfs_block_map_open>       <== NOT EXECUTED
 201edd0:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
 201edd4:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    if (rc > 0)                                                       
 201edd8:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
 201eddc:	14 80 00 29 	bg  201ee80 <rtems_rfs_symlink_read+0x1a0>     <== NOT EXECUTED
 201ede0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);              
 201ede4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
 201ede8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
 201edec:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
 201edf0:	7f ff ee c6 	call  201a908 <rtems_rfs_block_map_seek>       <== NOT EXECUTED
 201edf4:	98 07 bf 78 	add  %fp, -136, %o4                            <== NOT EXECUTED
    if (rc > 0)                                                       
 201edf8:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 201edfc:	14 80 00 0c 	bg  201ee2c <rtems_rfs_symlink_read+0x14c>     <== NOT EXECUTED
 201ee00:	90 10 00 1d 	mov  %i5, %o0                                  <== 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); 
 201ee04:	d4 07 bf 78 	ld  [ %fp + -136 ], %o2                        <== NOT EXECUTED
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
 201ee08:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201ee0c:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201ee10:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
 201ee14:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
 201ee18:	7f ff f1 78 	call  201b3f8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
 201ee1c:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
    if (rc > 0)                                                       
 201ee20:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 201ee24:	04 80 00 06 	ble  201ee3c <rtems_rfs_symlink_read+0x15c>    <== NOT EXECUTED
 201ee28:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_block_map_close (fs, &map);                           
 201ee2c:	7f ff ed e7 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201ee30:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_close (fs, &map);                        
    if (rc > 0)                                                       
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
 201ee34:	10 80 00 13 	b  201ee80 <rtems_rfs_symlink_read+0x1a0>      <== NOT EXECUTED
 201ee38:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    data = rtems_rfs_buffer_data (&buffer);                           
    memcpy (path, data, *length);                                     
 201ee3c:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
 201ee40:	d4 07 00 00 	ld  [ %i4 ], %o2                               <== NOT EXECUTED
 201ee44:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
 201ee48:	40 00 0b 42 	call  2021b50 <memcpy>                         <== NOT EXECUTED
 201ee4c:	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);                       
 201ee50:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
 201ee54:	7f ff f0 f5 	call  201b228 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
 201ee58:	90 10 00 1d 	mov  %i5, %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);                        
 201ee5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
 201ee60:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
 201ee64:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
 201ee68:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
 201ee6c:	7f ff ed d7 	call  201a5c8 <rtems_rfs_block_map_close>      <== NOT EXECUTED
 201ee70:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
 201ee74:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
 201ee78:	04 80 00 06 	ble  201ee90 <rtems_rfs_symlink_read+0x1b0>    <== NOT EXECUTED
 201ee7c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
 201ee80:	7f ff cc 0b 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201ee84:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
 201ee88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201ee8c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
 201ee90:	7f ff cc 07 	call  2011eac <rtems_rfs_inode_close>          
 201ee94:	92 07 bf 88 	add  %fp, -120, %o1                            
 201ee98:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  return rc;                                                          
}                                                                     
 201ee9c:	81 c7 e0 08 	ret                                            
 201eea0:	81 e8 00 00 	restore                                        
                                                                      

02013748 <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;
 2013748:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     <== NOT EXECUTED
 201374c:	c4 18 61 a0 	ldd  [ %g1 + 0x1a0 ], %g2	! 20465a0 <rtems_rfs_trace_flags><== NOT EXECUTED
  rtems_rfs_trace_flags &= ~mask;                                     
 2013750:	90 28 80 08 	andn  %g2, %o0, %o0                            <== NOT EXECUTED
 2013754:	92 28 c0 09 	andn  %g3, %o1, %o1                            <== NOT EXECUTED
 2013758:	d0 38 61 a0 	std  %o0, [ %g1 + 0x1a0 ]                      <== NOT EXECUTED
  return state;                                                       
}                                                                     
 201375c:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
 2013760:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2013764:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
                                                                      

02013728 <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;
 2013728:	03 00 81 19 	sethi  %hi(0x2046400), %g1                     <== NOT EXECUTED
 201372c:	c4 18 61 a0 	ldd  [ %g1 + 0x1a0 ], %g2	! 20465a0 <rtems_rfs_trace_flags><== NOT EXECUTED
  rtems_rfs_trace_flags |= mask;                                      
 2013730:	90 12 00 02 	or  %o0, %g2, %o0                              <== NOT EXECUTED
 2013734:	92 12 40 03 	or  %o1, %g3, %o1                              <== NOT EXECUTED
 2013738:	d0 38 61 a0 	std  %o0, [ %g1 + 0x1a0 ]                      <== NOT EXECUTED
  return state;                                                       
}                                                                     
 201373c:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
 2013740:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
 2013744:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
                                                                      

02013768 <rtems_rfs_trace_shell_command>: int rtems_rfs_trace_shell_command (int argc, char *argv[]) {
 2013768:	9d e3 be f8 	save  %sp, -264, %sp                           <== NOT EXECUTED
  const char* table[] =                                               
 201376c:	13 00 80 cc 	sethi  %hi(0x2033000), %o1                     <== NOT EXECUTED
 2013770:	90 07 bf 64 	add  %fp, -156, %o0                            <== NOT EXECUTED
 2013774:	92 12 60 e4 	or  %o1, 0xe4, %o1                             <== NOT EXECUTED
 2013778:	94 10 20 9c 	mov  0x9c, %o2                                 <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (strcmp (argv[arg], "set") == 0)                             
 201377c:	27 00 80 c3 	sethi  %hi(0x2030c00), %l3                     <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
 2013780:	29 00 80 cb 	sethi  %hi(0x2032c00), %l4                     <== NOT EXECUTED
}                                                                     
                                                                      
int                                                                   
rtems_rfs_trace_shell_command (int argc, char *argv[])                
{                                                                     
  const char* table[] =                                               
 2013784:	40 00 38 f3 	call  2021b50 <memcpy>                         <== NOT EXECUTED
 2013788:	2b 00 80 cb 	sethi  %hi(0x2032c00), %l5                     <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
 201378c:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
 2013790:	a2 10 20 01 	mov  1, %l1                                    <== NOT EXECUTED
    "file-io",                                                        
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
  rtems_rfs_trace_mask clear_value = 0;                               
 2013794:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
 2013798:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
    "file-close",                                                     
    "file-io",                                                        
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
 201379c:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
 20137a0:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (strcmp (argv[arg], "set") == 0)                             
 20137a4:	a6 14 e0 18 	or  %l3, 0x18, %l3                             <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
 20137a8:	a8 15 22 78 	or  %l4, 0x278, %l4                            <== NOT EXECUTED
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
 20137ac:	aa 15 62 80 	or  %l5, 0x280, %l5                            <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
 20137b0:	10 80 00 68 	b  2013950 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
 20137b4:	25 00 81 19 	sethi  %hi(0x2046400), %l2                     <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
 20137b8:	ec 06 40 01 	ld  [ %i1 + %g1 ], %l6                         <== NOT EXECUTED
 20137bc:	c2 4d 80 00 	ldsb  [ %l6 ], %g1                             <== NOT EXECUTED
 20137c0:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
 20137c4:	12 80 00 25 	bne  2013858 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
 20137c8:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
 20137cc:	c2 4d a0 01 	ldsb  [ %l6 + 1 ], %g1                         <== NOT EXECUTED
 20137d0:	80 a0 60 68 	cmp  %g1, 0x68                                 <== NOT EXECUTED
 20137d4:	02 80 00 06 	be  20137ec <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
 20137d8:	80 a0 60 6c 	cmp  %g1, 0x6c                                 <== NOT EXECUTED
 20137dc:	32 80 00 1a 	bne,a   2013844 <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
 20137e0:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== 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]); 
 20137e4:	10 80 00 08 	b  2013804 <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
 20137e8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'h':                                                     
          printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);  
 20137ec:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
 20137f0:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
 20137f4:	40 00 39 e4 	call  2021f84 <printf>                         <== NOT EXECUTED
 20137f8:	90 12 22 08 	or  %o0, 0x208, %o0	! 2032e08 <rtems_rfs_rtems_eval_config+0x30><== NOT EXECUTED
          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++)
            printf ("  %s\n", table[t]);                              
          return 0;                                                   
 20137fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013800:	91 e8 20 00 	restore  %g0, 0, %o0                           <== 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]); 
 2013804:	11 00 80 cb 	sethi  %hi(0x2032c00), %o0                     <== NOT EXECUTED
          for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
            printf ("  %s\n", table[t]);                              
 2013808:	39 00 80 cb 	sethi  %hi(0x2032c00), %i4                     <== 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]); 
 201380c:	90 12 22 30 	or  %o0, 0x230, %o0                            <== NOT EXECUTED
 2013810:	40 00 39 dd 	call  2021f84 <printf>                         <== NOT EXECUTED
 2013814:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
          for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
            printf ("  %s\n", table[t]);                              
 2013818:	b8 17 22 58 	or  %i4, 0x258, %i4                            <== NOT EXECUTED
 201381c:	82 07 bf 64 	add  %fp, -156, %g1                            <== NOT EXECUTED
 2013820:	d2 00 40 1d 	ld  [ %g1 + %i5 ], %o1                         <== NOT EXECUTED
 2013824:	40 00 39 d8 	call  2021f84 <printf>                         <== NOT EXECUTED
 2013828:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
 201382c:	ba 07 60 04 	add  %i5, 4, %i5                               <== 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++)
 2013830:	80 a7 60 9c 	cmp  %i5, 0x9c                                 <== NOT EXECUTED
 2013834:	12 bf ff fb 	bne  2013820 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
 2013838:	82 07 bf 64 	add  %fp, -156, %g1                            <== NOT EXECUTED
            printf ("  %s\n", table[t]);                              
          return 0;                                                   
 201383c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013840:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
        default:                                                      
          printf ("error: unknown option\n");                         
          return 1;                                                   
 2013844:	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");                         
 2013848:	40 00 3a 67 	call  20221e4 <puts>                           <== NOT EXECUTED
 201384c:	90 12 22 60 	or  %o0, 0x260, %o0                            <== NOT EXECUTED
 2013850:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2013854:	81 e8 00 00 	restore                                        <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (strcmp (argv[arg], "set") == 0)                             
 2013858:	40 00 3c 52 	call  20229a0 <strcmp>                         <== NOT EXECUTED
 201385c:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
 2013860:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2013864:	22 80 00 02 	be,a   201386c <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
 2013868:	a2 10 20 01 	mov  1, %l1                                    <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
 201386c:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
 2013870:	40 00 3c 4c 	call  20229a0 <strcmp>                         <== NOT EXECUTED
 2013874:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
 2013878:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 201387c:	22 80 00 2e 	be,a   2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
 2013880:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
 2013884:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
 2013888:	40 00 3c 46 	call  20229a0 <strcmp>                         <== NOT EXECUTED
 201388c:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
 2013890:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2013894:	12 80 00 09 	bne  20138b8 <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
 2013898:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
      {                                                               
        if (set)                                                      
 201389c:	80 8c 60 ff 	btst  0xff, %l1                                <== NOT EXECUTED
 20138a0:	22 80 00 23 	be,a   201392c <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
 20138a4:	35 3f ff ff 	sethi  %hi(0xfffffc00), %i2                    <== NOT EXECUTED
          set_value = RTEMS_RFS_TRACE_ALL;                            
 20138a8:	39 3f ff ff 	sethi  %hi(0xfffffc00), %i4                    <== NOT EXECUTED
 20138ac:	b8 17 23 ff 	or  %i4, 0x3ff, %i4	! ffffffff <RAM_END+0xfdbfffff><== NOT EXECUTED
 20138b0:	10 80 00 21 	b  2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
 20138b4:	ba 10 00 1c 	mov  %i4, %i5                                  <== NOT EXECUTED
  rtems_rfs_trace_flags &= ~mask;                                     
  return state;                                                       
}                                                                     
                                                                      
int                                                                   
rtems_rfs_trace_shell_command (int argc, char *argv[])                
 20138b8:	83 2a a0 02 	sll  %o2, 2, %g1                               <== NOT EXECUTED
      }                                                               
      else                                                            
      {                                                               
        for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++) 
        {                                                             
          if (strcmp (argv[arg], table[t]) == 0)                      
 20138bc:	84 07 bf 64 	add  %fp, -156, %g2                            <== NOT EXECUTED
 20138c0:	d2 00 80 01 	ld  [ %g2 + %g1 ], %o1                         <== NOT EXECUTED
 20138c4:	90 10 00 16 	mov  %l6, %o0                                  <== NOT EXECUTED
 20138c8:	40 00 3c 36 	call  20229a0 <strcmp>                         <== NOT EXECUTED
 20138cc:	d4 27 bf 5c 	st  %o2, [ %fp + -164 ]                        <== NOT EXECUTED
 20138d0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 20138d4:	12 80 00 10 	bne  2013914 <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
 20138d8:	d4 07 bf 5c 	ld  [ %fp + -164 ], %o2                        <== NOT EXECUTED
          {                                                           
            if (set)                                                  
              set_value = 1ULL << t;                                  
 20138dc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
      {                                                               
        for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++) 
        {                                                             
          if (strcmp (argv[arg], table[t]) == 0)                      
          {                                                           
            if (set)                                                  
 20138e0:	80 8c 60 ff 	btst  0xff, %l1                                <== NOT EXECUTED
 20138e4:	02 80 00 07 	be  2013900 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
 20138e8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
              set_value = 1ULL << t;                                  
 20138ec:	40 00 6b 05 	call  202e500 <__ashldi3>                      <== NOT EXECUTED
 20138f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20138f4:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
 20138f8:	10 80 00 0f 	b  2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
 20138fc:	ba 10 00 09 	mov  %o1, %i5                                  <== NOT EXECUTED
            else                                                      
              clear_value = 1ULL << t;                                
 2013900:	40 00 6b 00 	call  202e500 <__ashldi3>                      <== NOT EXECUTED
 2013904:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2013908:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
 201390c:	10 80 00 0a 	b  2013934 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
 2013910:	b6 10 00 09 	mov  %o1, %i3                                  <== NOT EXECUTED
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
      }                                                               
      else                                                            
      {                                                               
        for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++) 
 2013914:	94 02 a0 01 	inc  %o2                                       <== NOT EXECUTED
 2013918:	80 a2 a0 27 	cmp  %o2, 0x27                                 <== NOT EXECUTED
 201391c:	12 bf ff e8 	bne  20138bc <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
 2013920:	83 2a a0 02 	sll  %o2, 2, %g1                               <== NOT EXECUTED
            break;                                                    
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_trace_flags |= set_value;                             
 2013924:	10 80 00 05 	b  2013938 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
 2013928:	c4 1c a1 a0 	ldd  [ %l2 + 0x1a0 ], %g2                      <== NOT EXECUTED
      else if (strcmp (argv[arg], "all") == 0)                        
      {                                                               
        if (set)                                                      
          set_value = RTEMS_RFS_TRACE_ALL;                            
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
 201392c:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            <== NOT EXECUTED
 2013930:	b6 10 00 1a 	mov  %i2, %i3                                  <== NOT EXECUTED
            break;                                                    
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_trace_flags |= set_value;                             
 2013934:	c4 1c a1 a0 	ldd  [ %l2 + 0x1a0 ], %g2                      <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
 2013938:	a0 04 20 01 	inc  %l0                                       <== NOT EXECUTED
            break;                                                    
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_trace_flags |= set_value;                             
 201393c:	84 17 00 02 	or  %i4, %g2, %g2                              <== NOT EXECUTED
 2013940:	86 17 40 03 	or  %i5, %g3, %g3                              <== NOT EXECUTED
      rtems_rfs_trace_flags &= ~clear_value;                          
 2013944:	84 28 80 1a 	andn  %g2, %i2, %g2                            <== NOT EXECUTED
 2013948:	86 28 c0 1b 	andn  %g3, %i3, %g3                            <== NOT EXECUTED
 201394c:	c4 3c a1 a0 	std  %g2, [ %l2 + 0x1a0 ]                      <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
 2013950:	80 a4 00 18 	cmp  %l0, %i0                                  <== NOT EXECUTED
 2013954:	06 bf ff 99 	bl  20137b8 <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
 2013958:	83 2c 20 02 	sll  %l0, 2, %g1                               <== NOT EXECUTED
 201395c:	30 bf ff b8 	b,a   201383c <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
                                                                      

0201e6cc <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) {
 201e6cc:	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))                       
 201e6d0:	90 10 20 00 	clr  %o0                                       
 201e6d4:	7f ff d4 0d 	call  2013708 <rtems_rfs_trace>                
 201e6d8:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
 201e6dc:	80 8a 20 ff 	btst  0xff, %o0                                
 201e6e0:	02 80 00 08 	be  201e700 <rtems_rfs_unlink+0x34>            <== ALWAYS TAKEN
 201e6e4:	90 10 00 18 	mov  %i0, %o0                                  
    printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
 201e6e8:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e6ec:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
 201e6f0:	90 12 21 10 	or  %o0, 0x110, %o0                            <== NOT EXECUTED
 201e6f4:	40 00 0e 24 	call  2021f84 <printf>                         <== NOT EXECUTED
 201e6f8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
 201e6fc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201e700:	92 10 00 1a 	mov  %i2, %o1                                  
 201e704:	94 07 bf d8 	add  %fp, -40, %o2                             
 201e708:	7f ff cd 77 	call  2011ce4 <rtems_rfs_inode_open>           
 201e70c:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201e710:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e714:	12 80 00 d7 	bne  201ea70 <rtems_rfs_unlink+0x3a4>          <== NEVER TAKEN
 201e718:	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)); 
 201e71c:	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);                    
 201e720:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         
 201e724:	83 28 60 08 	sll  %g1, 8, %g1                               
 201e728:	82 08 40 02 	and  %g1, %g2, %g1                             
 201e72c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
 201e730:	82 18 40 02 	xor  %g1, %g2, %g1                             
 201e734:	80 a0 00 01 	cmp  %g0, %g1                                  
 201e738:	a0 60 3f ff 	subx  %g0, -1, %l0                             
  if (dir)                                                            
 201e73c:	80 8c 20 ff 	btst  0xff, %l0                                
 201e740:	02 80 00 26 	be  201e7d8 <rtems_rfs_unlink+0x10c>           
 201e744:	80 a7 20 00 	cmp  %i4, 0                                    
  {                                                                   
    switch (dir_mode)                                                 
 201e748:	22 80 00 06 	be,a   201e760 <rtems_rfs_unlink+0x94>         <== NEVER TAKEN
 201e74c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e750:	80 a7 20 01 	cmp  %i4, 1                                    
 201e754:	12 80 00 22 	bne  201e7dc <rtems_rfs_unlink+0x110>          <== NEVER TAKEN
 201e758:	90 10 00 18 	mov  %i0, %o0                                  
 201e75c:	30 80 00 0f 	b,a   201e798 <rtems_rfs_unlink+0xcc>          
    {                                                                 
      case rtems_rfs_unlink_dir_denied:                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                 
 201e760:	7f ff d3 ea 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e764:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201e768:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e76c:	22 80 00 06 	be,a   201e784 <rtems_rfs_unlink+0xb8>         <== NOT EXECUTED
 201e770:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
          printf ("rtems-rfs: link is a directory\n");                
 201e774:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e778:	40 00 0e 9b 	call  20221e4 <puts>                           <== NOT EXECUTED
 201e77c:	90 12 21 40 	or  %o0, 0x140, %o0	! 2034940 <CSWTCH.2+0x1460><== NOT EXECUTED
        rtems_rfs_inode_close (fs, &target_inode);                    
 201e780:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201e784:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
 201e788:	7f ff cd c9 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201e78c:	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;                                                          
}                                                                     
 201e790:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 201e794:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
          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);                 
 201e798:	7f ff f8 dc 	call  201cb08 <rtems_rfs_dir_empty>            
 201e79c:	92 07 bf d8 	add  %fp, -40, %o1                             
        if (rc > 0)                                                   
 201e7a0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e7a4:	04 80 00 0d 	ble  201e7d8 <rtems_rfs_unlink+0x10c>          
 201e7a8:	90 10 20 00 	clr  %o0                                       
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))               
 201e7ac:	7f ff d3 d7 	call  2013708 <rtems_rfs_trace>                
 201e7b0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
 201e7b4:	80 8a 20 ff 	btst  0xff, %o0                                
 201e7b8:	22 80 00 97 	be,a   201ea14 <rtems_rfs_unlink+0x348>        <== ALWAYS TAKEN
 201e7bc:	90 10 00 18 	mov  %i0, %o0                                  
            printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
 201e7c0:	40 00 12 5d 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e7c4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e7c8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e7cc:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e7d0:	10 80 00 8e 	b  201ea08 <rtems_rfs_unlink+0x33c>            <== NOT EXECUTED
 201e7d4:	90 12 21 60 	or  %o0, 0x160, %o0	! 2034960 <CSWTCH.2+0x1480><== NOT EXECUTED
      default:                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
 201e7d8:	90 10 00 18 	mov  %i0, %o0                                  
 201e7dc:	92 10 00 19 	mov  %i1, %o1                                  
 201e7e0:	94 07 bf b0 	add  %fp, -80, %o2                             
 201e7e4:	7f ff cd 40 	call  2011ce4 <rtems_rfs_inode_open>           
 201e7e8:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
 201e7ec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e7f0:	02 80 00 0e 	be  201e828 <rtems_rfs_unlink+0x15c>           <== ALWAYS TAKEN
 201e7f4:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
 201e7f8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201e7fc:	7f ff d3 c3 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e800:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201e804:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e808:	22 80 00 83 	be,a   201ea14 <rtems_rfs_unlink+0x348>        <== NOT EXECUTED
 201e80c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: inode-open failed: %d: %s\n",         
 201e810:	40 00 12 49 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e814:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e818:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e81c:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e820:	10 80 00 7a 	b  201ea08 <rtems_rfs_unlink+0x33c>            <== NOT EXECUTED
 201e824:	90 12 21 80 	or  %o0, 0x180, %o0	! 2034980 <CSWTCH.2+0x14a0><== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);     
 201e828:	92 07 bf b0 	add  %fp, -80, %o1                             
 201e82c:	94 10 00 1a 	mov  %i2, %o2                                  
 201e830:	7f ff f6 d4 	call  201c380 <rtems_rfs_dir_del_entry>        
 201e834:	96 10 00 1b 	mov  %i3, %o3                                  
  if (rc > 0)                                                         
 201e838:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e83c:	04 80 00 0e 	ble  201e874 <rtems_rfs_unlink+0x1a8>          <== ALWAYS TAKEN
 201e840:	01 00 00 00 	nop                                            
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
 201e844:	90 10 20 00 	clr  %o0	! 0 <PROM_START>                      <== NOT EXECUTED
 201e848:	7f ff d3 b0 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e84c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201e850:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e854:	22 80 00 59 	be,a   201e9b8 <rtems_rfs_unlink+0x2ec>        <== NOT EXECUTED
 201e858:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",          
 201e85c:	40 00 12 36 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e860:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e864:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e868:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e86c:	10 80 00 50 	b  201e9ac <rtems_rfs_unlink+0x2e0>            <== NOT EXECUTED
 201e870:	90 12 21 b0 	or  %o0, 0x1b0, %o0	! 20349b0 <CSWTCH.2+0x14d0><== NOT EXECUTED
    rtems_rfs_inode_close (fs, &parent_inode);                        
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode);                  
 201e874:	7f ff ff 1e 	call  201e4ec <rtems_rfs_inode_get_links>      
 201e878:	90 07 bf d8 	add  %fp, -40, %o0                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
 201e87c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
    rtems_rfs_inode_close (fs, &parent_inode);                        
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  links = rtems_rfs_inode_get_links (&target_inode);                  
 201e880:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                       
 201e884:	7f ff d3 a1 	call  2013708 <rtems_rfs_trace>                
 201e888:	90 10 20 00 	clr  %o0                                       
 201e88c:	80 8a 20 ff 	btst  0xff, %o0                                
 201e890:	02 80 00 09 	be  201e8b4 <rtems_rfs_unlink+0x1e8>           <== ALWAYS TAKEN
 201e894:	83 2f 60 10 	sll  %i5, 0x10, %g1                            
    printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
 201e898:	95 2f 60 10 	sll  %i5, 0x10, %o2                            <== NOT EXECUTED
 201e89c:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e8a0:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 201e8a4:	90 12 21 e0 	or  %o0, 0x1e0, %o0                            <== NOT EXECUTED
 201e8a8:	40 00 0d b7 	call  2021f84 <printf>                         <== NOT EXECUTED
 201e8ac:	95 32 a0 10 	srl  %o2, 0x10, %o2                            <== NOT EXECUTED
                                                                      
  if (links > 1)                                                      
 201e8b0:	83 2f 60 10 	sll  %i5, 0x10, %g1                            <== NOT EXECUTED
 201e8b4:	83 30 60 10 	srl  %g1, 0x10, %g1                            
 201e8b8:	80 a0 60 01 	cmp  %g1, 1                                    
 201e8bc:	08 80 00 0a 	bleu  201e8e4 <rtems_rfs_unlink+0x218>         
 201e8c0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    links--;                                                          
 201e8c4:	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);                  
 201e8c8:	85 37 60 08 	srl  %i5, 8, %g2                               
 201e8cc:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
 201e8d0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
 201e8d4:	fa 28 60 01 	stb  %i5, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201e8d8:	82 10 20 01 	mov  1, %g1                                    
 201e8dc:	10 80 00 23 	b  201e968 <rtems_rfs_unlink+0x29c>            
 201e8e0:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
  else                                                                
  {                                                                   
    /*                                                                
     * Erasing the inode releases all blocks attached to it.          
     */                                                               
    rc = rtems_rfs_inode_delete (fs, &target_inode);                  
 201e8e4:	90 10 00 18 	mov  %i0, %o0                                  
 201e8e8:	7f ff cd 94 	call  2011f38 <rtems_rfs_inode_delete>         
 201e8ec:	92 07 bf d8 	add  %fp, -40, %o1                             
    if (rc > 0)                                                       
 201e8f0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e8f4:	04 80 00 0d 	ble  201e928 <rtems_rfs_unlink+0x25c>          <== ALWAYS TAKEN
 201e8f8:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                   
 201e8fc:	7f ff d3 83 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e900:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201e904:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e908:	22 80 00 2c 	be,a   201e9b8 <rtems_rfs_unlink+0x2ec>        <== NOT EXECUTED
 201e90c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
        printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",      
 201e910:	40 00 12 09 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e914:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e918:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e91c:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e920:	10 80 00 23 	b  201e9ac <rtems_rfs_unlink+0x2e0>            <== NOT EXECUTED
 201e924:	90 12 22 08 	or  %o0, 0x208, %o0	! 2034a08 <CSWTCH.2+0x1528><== NOT EXECUTED
      rtems_rfs_inode_close (fs, &parent_inode);                      
      rtems_rfs_inode_close (fs, &target_inode);                      
      return rc;                                                      
    }                                                                 
                                                                      
    if (dir)                                                          
 201e928:	80 8c 20 ff 	btst  0xff, %l0                                
 201e92c:	02 80 00 10 	be  201e96c <rtems_rfs_unlink+0x2a0>           
 201e930:	90 07 bf b0 	add  %fp, -80, %o0                             
    {                                                                 
      links = rtems_rfs_inode_get_links (&parent_inode);              
 201e934:	7f ff fe ee 	call  201e4ec <rtems_rfs_inode_get_links>      
 201e938:	90 07 bf b0 	add  %fp, -80, %o0                             
      if (links > 1)                                                  
 201e93c:	80 a2 20 01 	cmp  %o0, 1                                    
 201e940:	08 80 00 03 	bleu  201e94c <rtems_rfs_unlink+0x280>         
 201e944:	82 10 00 08 	mov  %o0, %g1                                  
        links--;                                                      
 201e948:	82 02 3f ff 	add  %o0, -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);                  
 201e94c:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         
 201e950:	87 30 60 08 	srl  %g1, 8, %g3                               
 201e954:	c6 28 80 00 	stb  %g3, [ %g2 ]                              
 201e958:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         
 201e95c:	c2 28 a0 01 	stb  %g1, [ %g2 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
 201e960:	82 10 20 01 	mov  1, %g1                                    
 201e964:	c2 2f bf c0 	stb  %g1, [ %fp + -64 ]                        
      rtems_rfs_inode_set_links (&parent_inode, links);               
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);    
 201e968:	90 07 bf b0 	add  %fp, -80, %o0                             
 201e96c:	92 10 20 01 	mov  1, %o1                                    
 201e970:	7f ff cd a7 	call  201200c <rtems_rfs_inode_time_stamp_now> 
 201e974:	94 10 20 01 	mov  1, %o2                                    
  if (rc > 0)                                                         
 201e978:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e97c:	04 80 00 13 	ble  201e9c8 <rtems_rfs_unlink+0x2fc>          <== ALWAYS TAKEN
 201e980:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
 201e984:	7f ff d3 61 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e988:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201e98c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e990:	22 80 00 0a 	be,a   201e9b8 <rtems_rfs_unlink+0x2ec>        <== NOT EXECUTED
 201e994:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",   
 201e998:	40 00 11 e7 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e99c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e9a0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201e9a4:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201e9a8:	90 12 22 38 	or  %o0, 0x238, %o0	! 2034a38 <CSWTCH.2+0x1558><== NOT EXECUTED
 201e9ac:	40 00 0d 76 	call  2021f84 <printf>                         <== NOT EXECUTED
 201e9b0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &parent_inode);                        
 201e9b4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201e9b8:	7f ff cd 3d 	call  2011eac <rtems_rfs_inode_close>          <== NOT EXECUTED
 201e9bc:	92 07 bf b0 	add  %fp, -80, %o1                             <== 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);                        
 201e9c0:	10 80 00 15 	b  201ea14 <rtems_rfs_unlink+0x348>            <== NOT EXECUTED
 201e9c4:	90 10 00 18 	mov  %i0, %o0                                  <== 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);                     
 201e9c8:	90 10 00 18 	mov  %i0, %o0                                  
 201e9cc:	7f ff cd 38 	call  2011eac <rtems_rfs_inode_close>          
 201e9d0:	92 07 bf b0 	add  %fp, -80, %o1                             
  if (rc > 0)                                                         
 201e9d4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201e9d8:	04 80 00 13 	ble  201ea24 <rtems_rfs_unlink+0x358>          <== ALWAYS TAKEN
 201e9dc:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
 201e9e0:	7f ff d3 4a 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201e9e4:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201e9e8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201e9ec:	02 80 00 0a 	be  201ea14 <rtems_rfs_unlink+0x348>           <== NOT EXECUTED
 201e9f0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n", 
 201e9f4:	40 00 11 d0 	call  2023134 <strerror>                       <== NOT EXECUTED
 201e9f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201e9fc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201ea00:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201ea04:	90 12 22 70 	or  %o0, 0x270, %o0	! 2034a70 <CSWTCH.2+0x1590><== NOT EXECUTED
 201ea08:	40 00 0d 5f 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ea0c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
 201ea10:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
 201ea14:	7f ff cd 26 	call  2011eac <rtems_rfs_inode_close>          
 201ea18:	92 07 bf d8 	add  %fp, -40, %o1                             
  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;                                                          
}                                                                     
 201ea1c:	81 c7 e0 08 	ret                                            
 201ea20:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
 201ea24:	90 10 00 18 	mov  %i0, %o0                                  
 201ea28:	7f ff cd 21 	call  2011eac <rtems_rfs_inode_close>          
 201ea2c:	92 07 bf d8 	add  %fp, -40, %o1                             
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))           
 201ea30:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 201ea34:	04 80 00 10 	ble  201ea74 <rtems_rfs_unlink+0x3a8>          <== ALWAYS TAKEN
 201ea38:	b0 10 00 1d 	mov  %i5, %i0                                  
 201ea3c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
 201ea40:	7f ff d3 32 	call  2013708 <rtems_rfs_trace>                <== NOT EXECUTED
 201ea44:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
 201ea48:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
 201ea4c:	22 80 00 0a 	be,a   201ea74 <rtems_rfs_unlink+0x3a8>        <== NOT EXECUTED
 201ea50:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
    printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",   
 201ea54:	40 00 11 b8 	call  2023134 <strerror>                       <== NOT EXECUTED
 201ea58:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 201ea5c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
 201ea60:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 201ea64:	11 00 80 d2 	sethi  %hi(0x2034800), %o0                     <== NOT EXECUTED
 201ea68:	40 00 0d 47 	call  2021f84 <printf>                         <== NOT EXECUTED
 201ea6c:	90 12 22 a8 	or  %o0, 0x2a8, %o0	! 2034aa8 <CSWTCH.2+0x15c8><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  return rc;                                                          
}                                                                     
 201ea70:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
 201ea74:	81 c7 e0 08 	ret                                            
 201ea78:	81 e8 00 00 	restore                                        
                                                                      

02020d88 <rtems_shell_rfs_format>: int rtems_shell_rfs_format (int argc, char* argv[]) {
 2020d88:	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));              
 2020d8c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2020d90:	90 07 bf e8 	add  %fp, -24, %o0                             <== NOT EXECUTED
 2020d94:	94 10 20 18 	mov  0x18, %o2                                 <== NOT EXECUTED
 2020d98:	40 00 65 0d 	call  203a1cc <memset>                         <== NOT EXECUTED
 2020d9c:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
                                                                      
int                                                                   
rtems_shell_rfs_format (int argc, char* argv[])                       
{                                                                     
  rtems_rfs_format_config config;                                     
  const char*             driver = NULL;                              
 2020da0:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
 2020da4:	10 80 00 5b 	b  2020f10 <rtems_shell_rfs_format+0x188>      <== NOT EXECUTED
 2020da8:	b6 10 20 01 	mov  1, %i3                                    <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
 2020dac:	d2 06 40 01 	ld  [ %i1 + %g1 ], %o1                         <== NOT EXECUTED
 2020db0:	c2 4a 40 00 	ldsb  [ %o1 ], %g1                             <== NOT EXECUTED
 2020db4:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
 2020db8:	12 80 00 4e 	bne  2020ef0 <rtems_shell_rfs_format+0x168>    <== NOT EXECUTED
 2020dbc:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
 2020dc0:	c2 4a 60 01 	ldsb  [ %o1 + 1 ], %g1                         <== NOT EXECUTED
 2020dc4:	80 a0 60 69 	cmp  %g1, 0x69                                 <== NOT EXECUTED
 2020dc8:	22 80 00 2e 	be,a   2020e80 <rtems_shell_rfs_format+0xf8>   <== NOT EXECUTED
 2020dcc:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
 2020dd0:	14 80 00 09 	bg  2020df4 <rtems_shell_rfs_format+0x6c>      <== NOT EXECUTED
 2020dd4:	80 a0 60 73 	cmp  %g1, 0x73                                 <== NOT EXECUTED
 2020dd8:	80 a0 60 49 	cmp  %g1, 0x49                                 <== NOT EXECUTED
 2020ddc:	02 80 00 35 	be  2020eb0 <rtems_shell_rfs_format+0x128>     <== NOT EXECUTED
 2020de0:	80 a0 60 62 	cmp  %g1, 0x62                                 <== NOT EXECUTED
 2020de4:	12 80 00 41 	bne  2020ee8 <rtems_shell_rfs_format+0x160>    <== NOT EXECUTED
 2020de8:	11 00 81 57 	sethi  %hi(0x2055c00), %o0                     <== NOT EXECUTED
          }                                                           
          config.block_size = strtoul (argv[arg], 0, 0);              
          break;                                                      
                                                                      
        case 'b':                                                     
          arg++;                                                      
 2020dec:	10 80 00 19 	b  2020e50 <rtems_shell_rfs_format+0xc8>       <== NOT EXECUTED
 2020df0:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
 2020df4:	02 80 00 0a 	be  2020e1c <rtems_shell_rfs_format+0x94>      <== NOT EXECUTED
 2020df8:	80 a0 60 76 	cmp  %g1, 0x76                                 <== NOT EXECUTED
 2020dfc:	02 80 00 06 	be  2020e14 <rtems_shell_rfs_format+0x8c>      <== NOT EXECUTED
 2020e00:	80 a0 60 6f 	cmp  %g1, 0x6f                                 <== NOT EXECUTED
 2020e04:	12 80 00 39 	bne  2020ee8 <rtems_shell_rfs_format+0x160>    <== NOT EXECUTED
 2020e08:	11 00 81 57 	sethi  %hi(0x2055c00), %o0                     <== NOT EXECUTED
        case 'I':                                                     
          config.initialise_inodes = true;                            
          break;                                                      
                                                                      
        case 'o':                                                     
          arg++;                                                      
 2020e0c:	10 80 00 2b 	b  2020eb8 <rtems_shell_rfs_format+0x130>      <== NOT EXECUTED
 2020e10:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
      {                                                               
        case 'v':                                                     
          config.verbose = true;                                      
          break;                                                      
 2020e14:	10 80 00 3e 	b  2020f0c <rtems_shell_rfs_format+0x184>      <== NOT EXECUTED
 2020e18:	f6 2f bf fd 	stb  %i3, [ %fp + -3 ]                         <== NOT EXECUTED
                                                                      
        case 's':                                                     
          arg++;                                                      
 2020e1c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
 2020e20:	80 a7 40 18 	cmp  %i5, %i0                                  <== NOT EXECUTED
 2020e24:	06 80 00 05 	bl  2020e38 <rtems_shell_rfs_format+0xb0>      <== NOT EXECUTED
 2020e28:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: block size needs an argument\n");         
 2020e2c:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020e30:	10 80 00 40 	b  2020f30 <rtems_shell_rfs_format+0x1a8>      <== NOT EXECUTED
 2020e34:	90 12 22 98 	or  %o0, 0x298, %o0	! 2057e98 <rtems_rtc_shell_usage+0x17a0><== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.block_size = strtoul (argv[arg], 0, 0);              
 2020e38:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
 2020e3c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2020e40:	40 00 79 4f 	call  203f37c <strtoul>                        <== NOT EXECUTED
 2020e44:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
 2020e48:	10 80 00 31 	b  2020f0c <rtems_shell_rfs_format+0x184>      <== NOT EXECUTED
 2020e4c:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         <== NOT EXECUTED
                                                                      
        case 'b':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
 2020e50:	80 a7 40 18 	cmp  %i5, %i0                                  <== NOT EXECUTED
 2020e54:	06 80 00 05 	bl  2020e68 <rtems_shell_rfs_format+0xe0>      <== NOT EXECUTED
 2020e58:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: group block count needs an argument\n");  
 2020e5c:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020e60:	10 80 00 34 	b  2020f30 <rtems_shell_rfs_format+0x1a8>      <== NOT EXECUTED
 2020e64:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 2057ec0 <rtems_rtc_shell_usage+0x17c8><== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.group_blocks = strtoul (argv[arg], 0, 0);            
 2020e68:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
 2020e6c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2020e70:	40 00 79 43 	call  203f37c <strtoul>                        <== NOT EXECUTED
 2020e74:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
 2020e78:	10 80 00 25 	b  2020f0c <rtems_shell_rfs_format+0x184>      <== NOT EXECUTED
 2020e7c:	d0 27 bf ec 	st  %o0, [ %fp + -20 ]                         <== NOT EXECUTED
                                                                      
        case 'i':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
 2020e80:	80 a7 40 18 	cmp  %i5, %i0                                  <== NOT EXECUTED
 2020e84:	06 80 00 05 	bl  2020e98 <rtems_shell_rfs_format+0x110>     <== NOT EXECUTED
 2020e88:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: group inode count needs an argument\n");  
 2020e8c:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020e90:	10 80 00 28 	b  2020f30 <rtems_shell_rfs_format+0x1a8>      <== NOT EXECUTED
 2020e94:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 2057ef0 <rtems_rtc_shell_usage+0x17f8><== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.group_inodes = strtoul (argv[arg], 0, 0);            
 2020e98:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
 2020e9c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2020ea0:	40 00 79 37 	call  203f37c <strtoul>                        <== NOT EXECUTED
 2020ea4:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
 2020ea8:	10 80 00 19 	b  2020f0c <rtems_shell_rfs_format+0x184>      <== NOT EXECUTED
 2020eac:	d0 27 bf f0 	st  %o0, [ %fp + -16 ]                         <== NOT EXECUTED
                                                                      
        case 'I':                                                     
          config.initialise_inodes = true;                            
          break;                                                      
 2020eb0:	10 80 00 17 	b  2020f0c <rtems_shell_rfs_format+0x184>      <== NOT EXECUTED
 2020eb4:	f6 2f bf fc 	stb  %i3, [ %fp + -4 ]                         <== NOT EXECUTED
                                                                      
        case 'o':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
 2020eb8:	80 a7 40 18 	cmp  %i5, %i0                                  <== NOT EXECUTED
 2020ebc:	06 80 00 05 	bl  2020ed0 <rtems_shell_rfs_format+0x148>     <== NOT EXECUTED
 2020ec0:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
 2020ec4:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020ec8:	10 80 00 1a 	b  2020f30 <rtems_shell_rfs_format+0x1a8>      <== NOT EXECUTED
 2020ecc:	90 12 23 20 	or  %o0, 0x320, %o0	! 2057f20 <rtems_rtc_shell_usage+0x1828><== NOT EXECUTED
            return 1;                                                 
          }                                                           
          config.inode_overhead = strtoul (argv[arg], 0, 0);          
 2020ed0:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
 2020ed4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
 2020ed8:	40 00 79 29 	call  203f37c <strtoul>                        <== NOT EXECUTED
 2020edc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
 2020ee0:	10 80 00 0b 	b  2020f0c <rtems_shell_rfs_format+0x184>      <== NOT EXECUTED
 2020ee4:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         <== NOT EXECUTED
                                                                      
        default:                                                      
          printf ("error: invalid option: %s\n", argv[arg]);          
 2020ee8:	10 80 00 06 	b  2020f00 <rtems_shell_rfs_format+0x178>      <== NOT EXECUTED
 2020eec:	90 12 23 68 	or  %o0, 0x368, %o0                            <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (!driver)                                                    
 2020ef0:	22 80 00 07 	be,a   2020f0c <rtems_shell_rfs_format+0x184>  <== NOT EXECUTED
 2020ef4:	b8 10 00 09 	mov  %o1, %i4                                  <== NOT EXECUTED
        driver = argv[arg];                                           
      else                                                            
      {                                                               
        printf ("error: only one driver name allowed: %s\n", argv[arg]);
 2020ef8:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020efc:	90 12 23 58 	or  %o0, 0x358, %o0	! 2057f58 <rtems_rtc_shell_usage+0x1860><== NOT EXECUTED
 2020f00:	40 00 69 24 	call  203b390 <printf>                         <== NOT EXECUTED
 2020f04:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
 2020f08:	30 80 00 1c 	b,a   2020f78 <rtems_shell_rfs_format+0x1f0>   <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
 2020f0c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
 2020f10:	80 a7 40 18 	cmp  %i5, %i0                                  <== NOT EXECUTED
 2020f14:	06 bf ff a6 	bl  2020dac <rtems_shell_rfs_format+0x24>      <== NOT EXECUTED
 2020f18:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
        return 1;                                                     
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
 2020f1c:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
 2020f20:	12 80 00 07 	bne  2020f3c <rtems_shell_rfs_format+0x1b4>    <== NOT EXECUTED
 2020f24:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    printf ("error: no driver name provided\n");                      
 2020f28:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020f2c:	90 12 23 88 	or  %o0, 0x388, %o0	! 2057f88 <rtems_rtc_shell_usage+0x1890><== NOT EXECUTED
 2020f30:	40 00 69 b0 	call  203b5f0 <puts>                           <== NOT EXECUTED
 2020f34:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
 2020f38:	30 80 00 10 	b,a   2020f78 <rtems_shell_rfs_format+0x1f0>   <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_format (driver, &config) < 0)                         
 2020f3c:	92 07 bf e8 	add  %fp, -24, %o1                             <== NOT EXECUTED
 2020f40:	40 00 34 4e 	call  202e078 <rtems_rfs_format>               <== NOT EXECUTED
 2020f44:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 2020f48:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
 2020f4c:	16 80 00 0b 	bge  2020f78 <rtems_shell_rfs_format+0x1f0>    <== NOT EXECUTED
 2020f50:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    printf ("error: format of %s failed: %s\n",                       
            driver, strerror (errno));                                
 2020f54:	40 00 56 c0 	call  2036a54 <__errno>                        <== NOT EXECUTED
 2020f58:	b0 10 20 01 	mov  1, %i0	! 1 <PROM_START+0x1>               <== NOT EXECUTED
    return 1;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_format (driver, &config) < 0)                         
  {                                                                   
    printf ("error: format of %s failed: %s\n",                       
 2020f5c:	40 00 72 8b 	call  203d988 <strerror>                       <== NOT EXECUTED
 2020f60:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
 2020f64:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
 2020f68:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
 2020f6c:	11 00 81 5f 	sethi  %hi(0x2057c00), %o0                     <== NOT EXECUTED
 2020f70:	40 00 69 08 	call  203b390 <printf>                         <== NOT EXECUTED
 2020f74:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 2057fa8 <rtems_rtc_shell_usage+0x18b0><== NOT EXECUTED
            driver, strerror (errno));                                
    return 1;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
 2020f78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2020f7c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0201789c <rtems_signal_send>: rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) {
 201789c:	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 )                                                  
 20178a0:	80 a6 60 00 	cmp  %i1, 0                                    
 20178a4:	02 80 00 35 	be  2017978 <rtems_signal_send+0xdc>           
 20178a8:	82 10 20 0a 	mov  0xa, %g1                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 20178ac:	90 10 00 18 	mov  %i0, %o0                                  
 20178b0:	40 00 12 ca 	call  201c3d8 <_Thread_Get>                    
 20178b4:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 20178b8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20178bc:	80 a0 60 00 	cmp  %g1, 0                                    
 20178c0:	12 80 00 2d 	bne  2017974 <rtems_signal_send+0xd8>          
 20178c4:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
 20178c8:	fa 02 21 58 	ld  [ %o0 + 0x158 ], %i5                       
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
 20178cc:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 20178d0:	80 a0 60 00 	cmp  %g1, 0                                    
 20178d4:	02 80 00 24 	be  2017964 <rtems_signal_send+0xc8>           
 20178d8:	01 00 00 00 	nop                                            
        if ( asr->is_enabled ) {                                      
 20178dc:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
 20178e0:	80 a0 60 00 	cmp  %g1, 0                                    
 20178e4:	02 80 00 15 	be  2017938 <rtems_signal_send+0x9c>           
 20178e8:	01 00 00 00 	nop                                            
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
 20178ec:	7f ff e3 91 	call  2010730 <sparc_disable_interrupts>       
 20178f0:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
 20178f4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 20178f8:	b2 10 40 19 	or  %g1, %i1, %i1                              
 20178fc:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
  _ISR_Enable( _level );                                              
 2017900:	7f ff e3 90 	call  2010740 <sparc_enable_interrupts>        
 2017904:	01 00 00 00 	nop                                            
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
 2017908:	03 00 80 f3 	sethi  %hi(0x203cc00), %g1                     
 201790c:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 203cee0 <_Per_CPU_Information>
 2017910:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
 2017914:	80 a0 a0 00 	cmp  %g2, 0                                    
 2017918:	02 80 00 0f 	be  2017954 <rtems_signal_send+0xb8>           
 201791c:	01 00 00 00 	nop                                            
 2017920:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
 2017924:	80 a7 00 02 	cmp  %i4, %g2                                  
 2017928:	12 80 00 0b 	bne  2017954 <rtems_signal_send+0xb8>          <== NEVER TAKEN
 201792c:	84 10 20 01 	mov  1, %g2                                    
            _Thread_Dispatch_necessary = true;                        
 2017930:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
 2017934:	30 80 00 08 	b,a   2017954 <rtems_signal_send+0xb8>         
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
 2017938:	7f ff e3 7e 	call  2010730 <sparc_disable_interrupts>       
 201793c:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
 2017940:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
 2017944:	b2 10 40 19 	or  %g1, %i1, %i1                              
 2017948:	f2 27 60 18 	st  %i1, [ %i5 + 0x18 ]                        
  _ISR_Enable( _level );                                              
 201794c:	7f ff e3 7d 	call  2010740 <sparc_enable_interrupts>        
 2017950:	01 00 00 00 	nop                                            
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
 2017954:	40 00 12 95 	call  201c3a8 <_Thread_Enable_dispatch>        
 2017958:	01 00 00 00 	nop                                            
        return RTEMS_SUCCESSFUL;                                      
 201795c:	10 80 00 07 	b  2017978 <rtems_signal_send+0xdc>            
 2017960:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
      }                                                               
      _Thread_Enable_dispatch();                                      
 2017964:	40 00 12 91 	call  201c3a8 <_Thread_Enable_dispatch>        
 2017968:	01 00 00 00 	nop                                            
      return RTEMS_NOT_DEFINED;                                       
 201796c:	10 80 00 03 	b  2017978 <rtems_signal_send+0xdc>            
 2017970:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
 2017974:	82 10 20 04 	mov  4, %g1                                    
}                                                                     
 2017978:	81 c7 e0 08 	ret                                            
 201797c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200ef2c <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 ) {
 200ef2c:	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 )           
 200ef30:	92 10 00 1a 	mov  %i2, %o1                                  
 200ef34:	7f ff cd c7 	call  2002650 <.umul>                          
 200ef38:	90 06 60 08 	add  %i1, 8, %o0                               
                                + key_table_size + data_size;         
                                                                      
  rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(         
 200ef3c:	7f ff da 50 	call  200587c <malloc>                         
 200ef40:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
 200ef44:	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 ) {                                        
 200ef48:	80 a2 60 00 	cmp  %o1, 0                                    
 200ef4c:	02 80 00 0b 	be  200ef78 <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
 200ef50:	90 10 20 1a 	mov  0x1a, %o0                                 
    sc = rtems_sparse_disk_register(                                  
 200ef54:	03 00 80 3a 	sethi  %hi(0x200e800), %g1                     
 200ef58:	82 10 63 b4 	or  %g1, 0x3b4, %g1	! 200ebb4 <rtems_sparse_disk_free>
 200ef5c:	90 10 00 18 	mov  %i0, %o0                                  
 200ef60:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
 200ef64:	94 10 00 19 	mov  %i1, %o2                                  
 200ef68:	96 10 00 1a 	mov  %i2, %o3                                  
 200ef6c:	98 10 00 1b 	mov  %i3, %o4                                  
 200ef70:	7f ff ff b7 	call  200ee4c <rtems_sparse_disk_register>     
 200ef74:	9a 10 00 1c 	mov  %i4, %o5                                  
  } else {                                                            
    sc = RTEMS_NO_MEMORY;                                             
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 200ef78:	81 c7 e0 08 	ret                                            
 200ef7c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

0200ee4c <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 ) {
 200ee4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
        sparse_disk_ioctl,                                            
        sparse_disk                                                   
      );                                                              
    }                                                                 
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
 200ee50:	90 10 20 0a 	mov  0xa, %o0                                  
  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 )               
{                                                                     
 200ee54:	a0 10 00 19 	mov  %i1, %l0                                  
 200ee58:	e4 07 a0 5c 	ld  [ %fp + 0x5c ], %l2                        
  rtems_status_code sc;                                               
                                                                      
  if ( blocks_with_buffer <= media_block_count ) {                    
 200ee5c:	80 a6 c0 1c 	cmp  %i3, %i4                                  
 200ee60:	18 80 00 31 	bgu  200ef24 <rtems_sparse_disk_register+0xd8> <== NEVER TAKEN
 200ee64:	b2 10 00 1a 	mov  %i2, %i1                                  
  const uint8_t                                                     fill_pattern )
{                                                                     
  rtems_status_code sc;                                               
  rtems_blkdev_bnum i;                                                
                                                                      
  if ( NULL == sd )                                                   
 200ee68:	80 a4 20 00 	cmp  %l0, 0                                    
 200ee6c:	02 80 00 2d 	be  200ef20 <rtems_sparse_disk_register+0xd4>  <== NEVER TAKEN
 200ee70:	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                    
 200ee74:	b5 2e e0 03 	sll  %i3, 3, %i2                               
                                * 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 );    
 200ee78:	90 10 00 10 	mov  %l0, %o0                                  
 200ee7c:	a2 06 a0 1c 	add  %i2, 0x1c, %l1                            
 200ee80:	40 00 34 c7 	call  201c19c <memset>                         
 200ee84:	94 10 00 11 	mov  %l1, %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;
 200ee88:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );    
                                                                      
  sd->fill_pattern = fill_pattern;                                    
 200ee8c:	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;
 200ee90:	7f ff cd f0 	call  2002650 <.umul>                          
 200ee94:	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 ),
 200ee98:	92 10 00 1d 	mov  %i5, %o1                                  
    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;
 200ee9c:	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 ),
 200eea0:	a2 04 00 11 	add  %l0, %l1, %l1                             
 200eea4:	40 00 34 be 	call  201c19c <memset>                         
 200eea8:	90 10 00 11 	mov  %l1, %o0                                  
          sd->fill_pattern,                                           
          data_size );                                                
                                                                      
  sd->delete_handler = sparse_disk_delete;                            
                                                                      
  sc                 = rtems_semaphore_create(                        
 200eeac:	11 14 d4 10 	sethi  %hi(0x53504000), %o0                    
  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;                            
 200eeb0:	e4 24 20 10 	st  %l2, [ %l0 + 0x10 ]                        
                                                                      
  sc                 = rtems_semaphore_create(                        
 200eeb4:	90 12 21 52 	or  %o0, 0x152, %o0                            
 200eeb8:	92 10 20 01 	mov  1, %o1                                    
 200eebc:	94 10 20 54 	mov  0x54, %o2                                 
 200eec0:	96 10 20 00 	clr  %o3                                       
 200eec4:	7f ff e9 d3 	call  2009610 <rtems_semaphore_create>         
 200eec8:	98 10 00 10 	mov  %l0, %o4                                  
    RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY, 
    0,                                                                
    &sd->mutex                                                        
    );                                                                
                                                                      
  if ( sc != RTEMS_SUCCESSFUL ) {                                     
 200eecc:	80 a2 20 00 	cmp  %o0, 0                                    
 200eed0:	12 80 00 15 	bne  200ef24 <rtems_sparse_disk_register+0xd8> <== NEVER TAKEN
 200eed4:	84 04 20 1c 	add  %l0, 0x1c, %g2                            
    return sc;                                                        
  }                                                                   
                                                                      
  data                  += sizeof( rtems_sparse_disk );               
                                                                      
  sd->blocks_with_buffer = blocks_with_buffer;                        
 200eed8:	f6 24 20 04 	st  %i3, [ %l0 + 4 ]                           
  sd->key_table          = (rtems_sparse_disk_key *) data;            
 200eedc:	c4 24 20 18 	st  %g2, [ %l0 + 0x18 ]                        
                                                                      
  data                  += key_table_size;                            
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
 200eee0:	82 10 20 00 	clr  %g1                                       
  data                  += sizeof( rtems_sparse_disk );               
                                                                      
  sd->blocks_with_buffer = blocks_with_buffer;                        
  sd->key_table          = (rtems_sparse_disk_key *) data;            
                                                                      
  data                  += key_table_size;                            
 200eee4:	10 80 00 06 	b  200eefc <rtems_sparse_disk_register+0xb0>   
 200eee8:	84 00 80 1a 	add  %g2, %i2, %g2                             
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
 200eeec:	82 00 60 01 	inc  %g1                                       
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
                                                                      
rtems_status_code rtems_sparse_disk_register(                         
 200eef0:	86 04 00 03 	add  %l0, %g3, %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;                                     
 200eef4:	c4 20 e0 20 	st  %g2, [ %g3 + 0x20 ]                        
  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 ) {
 200eef8:	84 00 80 19 	add  %g2, %i1, %g2                             
 200eefc:	80 a0 40 1b 	cmp  %g1, %i3                                  
 200ef00:	12 bf ff fb 	bne  200eeec <rtems_sparse_disk_register+0xa0> 
 200ef04:	87 28 60 03 	sll  %g1, 3, %g3                               
      sparse_disk_delete,                                             
      fill_pattern                                                    
    );                                                                
                                                                      
    if ( RTEMS_SUCCESSFUL == sc ) {                                   
      sc = rtems_blkdev_create(                                       
 200ef08:	b4 10 00 1c 	mov  %i4, %i2                                  
 200ef0c:	37 00 80 3a 	sethi  %hi(0x200e800), %i3                     
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
    sd->key_table[i].data = data;                                     
  }                                                                   
                                                                      
  sd->media_block_size = media_block_size;                            
 200ef10:	f2 24 20 0c 	st  %i1, [ %l0 + 0xc ]                         
      sparse_disk_delete,                                             
      fill_pattern                                                    
    );                                                                
                                                                      
    if ( RTEMS_SUCCESSFUL == sc ) {                                   
      sc = rtems_blkdev_create(                                       
 200ef14:	b6 16 e3 c0 	or  %i3, 0x3c0, %i3                            
 200ef18:	40 00 0a 93 	call  2011964 <rtems_blkdev_create>            
 200ef1c:	99 e8 00 10 	restore  %g0, %l0, %o4                         
{                                                                     
  rtems_status_code sc;                                               
  rtems_blkdev_bnum i;                                                
                                                                      
  if ( NULL == sd )                                                   
    return RTEMS_INVALID_ADDRESS;                                     
 200ef20:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
 200ef24:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200ef28:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

020226e0 <rtems_stack_checker_begin_extension>: * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) {
 20226e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Stack_check_Control  *the_pattern;                                  
                                                                      
  if ( the_thread->Object.id == 0 )        /* skip system tasks */    
 20226e4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
 20226e8:	80 a0 60 00 	cmp  %g1, 0                                    
 20226ec:	02 80 00 07 	be  2022708 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
 20226f0:	13 00 81 8a 	sethi  %hi(0x2062800), %o1                     
    return;                                                           
                                                                      
  the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
                                                                      
  *the_pattern = Stack_check_Pattern;                                 
 20226f4:	d0 06 20 b8 	ld  [ %i0 + 0xb8 ], %o0                        
 20226f8:	90 02 20 08 	add  %o0, 8, %o0                               
 20226fc:	92 12 62 8c 	or  %o1, 0x28c, %o1                            
 2022700:	40 00 5e 24 	call  2039f90 <memcpy>                         
 2022704:	94 10 20 10 	mov  0x10, %o2                                 
 2022708:	81 c7 e0 08 	ret                                            
 202270c:	81 e8 00 00 	restore                                        
                                                                      

02022628 <rtems_stack_checker_create_extension>: */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) {
 2022628:	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 )                                      
 202262c:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 2022630:	c2 00 60 a0 	ld  [ %g1 + 0xa0 ], %g1	! 20618a0 <Stack_check_Initialized>
 2022634:	80 a0 60 00 	cmp  %g1, 0                                    
 2022638:	12 80 00 21 	bne  20226bc <rtems_stack_checker_create_extension+0x94>
 202263c:	05 00 81 8a 	sethi  %hi(0x2062800), %g2                     
  /*                                                                  
   * Dope the pattern and fill areas                                  
   */                                                                 
  p = Stack_check_Pattern.pattern;                                    
  for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {                        
      p[i] = pattern[ i%4 ];                                          
 2022640:	07 3f bb 7c 	sethi  %hi(0xfeedf000), %g3                    
 2022644:	82 10 a2 8c 	or  %g2, 0x28c, %g1                            
 2022648:	86 10 e0 0d 	or  %g3, 0xd, %g3                              
 202264c:	c6 20 a2 8c 	st  %g3, [ %g2 + 0x28c ]                       
 2022650:	05 02 eb 43 	sethi  %hi(0xbad0c00), %g2                     
 2022654:	84 10 a1 06 	or  %g2, 0x106, %g2	! bad0d06 <RAM_END+0x96d0d06>
 2022658:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
 202265c:	05 37 ab 7c 	sethi  %hi(0xdeadf000), %g2                    
 2022660:	84 10 a0 0d 	or  %g2, 0xd, %g2	! deadf00d <RAM_END+0xdc6df00d>
 2022664:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
 2022668:	05 18 03 43 	sethi  %hi(0x600d0c00), %g2                    
 202266c:	84 10 a1 06 	or  %g2, 0x106, %g2	! 600d0d06 <RAM_END+0x5dcd0d06>
 2022670:	c4 20 60 0c 	st  %g2, [ %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) {      
 2022674:	03 00 81 89 	sethi  %hi(0x2062400), %g1                     
 2022678:	d0 00 61 60 	ld  [ %g1 + 0x160 ], %o0	! 2062560 <_Per_CPU_Information>
 202267c:	80 a2 20 00 	cmp  %o0, 0                                    
 2022680:	02 80 00 0c 	be  20226b0 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
 2022684:	84 10 61 60 	or  %g1, 0x160, %g2                            
 2022688:	d4 00 a0 04 	ld  [ %g2 + 4 ], %o2                           
 202268c:	80 a2 a0 00 	cmp  %o2, 0                                    
 2022690:	02 80 00 08 	be  20226b0 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
 2022694:	03 00 81 8a 	sethi  %hi(0x2062800), %g1                     
      Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;    
 2022698:	84 10 62 9c 	or  %g1, 0x29c, %g2	! 2062a9c <Stack_check_Interrupt_stack>
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
 202269c:	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;    
 20226a0:	d0 20 a0 04 	st  %o0, [ %g2 + 4 ]                           
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
 20226a4:	d4 20 62 9c 	st  %o2, [ %g1 + 0x29c ]                       
                                  (char *) _CPU_Interrupt_stack_low;  
      Stack_check_Dope_stack(&Stack_check_Interrupt_stack);           
 20226a8:	40 00 5e c9 	call  203a1cc <memset>                         
 20226ac:	92 10 20 a5 	mov  0xa5, %o1                                 
   }                                                                  
  #endif                                                              
                                                                      
  Stack_check_Initialized = 1;                                        
 20226b0:	84 10 20 01 	mov  1, %g2                                    
 20226b4:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 20226b8:	c4 20 60 a0 	st  %g2, [ %g1 + 0xa0 ]	! 20618a0 <Stack_check_Initialized>
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  Stack_check_Initialize();                                           
                                                                      
  if (the_thread)                                                     
 20226bc:	80 a6 60 00 	cmp  %i1, 0                                    
 20226c0:	02 80 00 06 	be  20226d8 <rtems_stack_checker_create_extension+0xb0><== NEVER TAKEN
 20226c4:	01 00 00 00 	nop                                            
    Stack_check_Dope_stack(&the_thread->Start.Initial_stack);         
 20226c8:	d0 06 60 b8 	ld  [ %i1 + 0xb8 ], %o0                        
 20226cc:	d4 06 60 b4 	ld  [ %i1 + 0xb4 ], %o2                        
 20226d0:	40 00 5e bf 	call  203a1cc <memset>                         
 20226d4:	92 10 20 a5 	mov  0xa5, %o1                                 
                                                                      
  return true;                                                        
}                                                                     
 20226d8:	81 c7 e0 08 	ret                                            
 20226dc:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

02022830 <rtems_stack_checker_is_blown>: /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) {
 2022830:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
 2022834:	03 00 81 89 	sethi  %hi(0x2062400), %g1                     
 2022838:	fa 00 61 70 	ld  [ %g1 + 0x170 ], %i5	! 2062570 <_Per_CPU_Information+0x10>
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
 202283c:	d0 07 60 b8 	ld  [ %i5 + 0xb8 ], %o0                        
 2022840:	80 a7 80 08 	cmp  %fp, %o0                                  
 2022844:	0a 80 00 06 	bcs  202285c <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
 2022848:	b8 10 20 00 	clr  %i4                                       
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
 202284c:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2022850:	82 02 00 01 	add  %o0, %g1, %g1                             
 2022854:	80 a0 40 1e 	cmp  %g1, %fp                                  
 2022858:	b8 60 3f ff 	subx  %g0, -1, %i4                             
                                                                      
  /*                                                                  
   * The stack checker must be initialized before the pattern is there
   * to check.                                                        
   */                                                                 
  if ( Stack_check_Initialized ) {                                    
 202285c:	03 00 81 86 	sethi  %hi(0x2061800), %g1                     
 2022860:	c2 00 60 a0 	ld  [ %g1 + 0xa0 ], %g1	! 20618a0 <Stack_check_Initialized>
 2022864:	80 a0 60 00 	cmp  %g1, 0                                    
 2022868:	02 80 00 09 	be  202288c <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
 202286c:	92 10 20 01 	mov  1, %o1                                    
    pattern_ok = (!memcmp(                                            
 2022870:	90 02 20 08 	add  %o0, 8, %o0                               
 2022874:	13 00 81 8a 	sethi  %hi(0x2062800), %o1                     
 2022878:	94 10 20 10 	mov  0x10, %o2                                 
 202287c:	40 00 5d 9b 	call  2039ee8 <memcmp>                         
 2022880:	92 12 62 8c 	or  %o1, 0x28c, %o1                            
 2022884:	80 a0 00 08 	cmp  %g0, %o0                                  
 2022888:	92 60 3f ff 	subx  %g0, -1, %o1                             
                                                                      
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  if ( !sp_ok || !pattern_ok ) {                                      
 202288c:	82 1a 60 01 	xor  %o1, 1, %g1                               
 2022890:	80 88 60 ff 	btst  0xff, %g1                                
 2022894:	12 80 00 05 	bne  20228a8 <rtems_stack_checker_is_blown+0x78><== NEVER TAKEN
 2022898:	b8 1f 20 01 	xor  %i4, 1, %i4                               
 202289c:	80 8f 20 ff 	btst  0xff, %i4                                
 20228a0:	02 80 00 05 	be  20228b4 <rtems_stack_checker_is_blown+0x84><== ALWAYS TAKEN
 20228a4:	01 00 00 00 	nop                                            
    Stack_check_report_blown_task( _Thread_Executing, pattern_ok );   
 20228a8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 20228ac:	7f ff ff 99 	call  2022710 <Stack_check_report_blown_task>  <== NOT EXECUTED
 20228b0:	92 0a 60 01 	and  %o1, 1, %o1                               <== NOT EXECUTED
                                                                      
  /*                                                                  
   * The Stack Pointer and the Pattern Area are OK so return false.   
   */                                                                 
  return false;                                                       
}                                                                     
 20228b4:	81 c7 e0 08 	ret                                            
 20228b8:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

020228bc <rtems_stack_checker_report_usage_with_plugin>: void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) {
 20228bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !print )                                                       
 20228c0:	80 a6 60 00 	cmp  %i1, 0                                    
 20228c4:	02 80 00 14 	be  2022914 <rtems_stack_checker_report_usage_with_plugin+0x58><== NEVER TAKEN
 20228c8:	39 00 81 86 	sethi  %hi(0x2061800), %i4                     
    return;                                                           
                                                                      
  print_context = context;                                            
  print_handler = print;                                              
 20228cc:	3b 00 81 86 	sethi  %hi(0x2061800), %i5                     
)                                                                     
{                                                                     
  if ( !print )                                                       
    return;                                                           
                                                                      
  print_context = context;                                            
 20228d0:	f0 27 20 a4 	st  %i0, [ %i4 + 0xa4 ]                        
  print_handler = print;                                              
 20228d4:	f2 27 60 a8 	st  %i1, [ %i5 + 0xa8 ]                        
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
 20228d8:	90 10 00 18 	mov  %i0, %o0                                  
 20228dc:	13 00 81 62 	sethi  %hi(0x2058800), %o1                     
 20228e0:	9f c6 40 00 	call  %i1                                      
 20228e4:	92 12 61 28 	or  %o1, 0x128, %o1	! 2058928 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8>
  (*print)( context,                                                  
 20228e8:	90 10 00 18 	mov  %i0, %o0                                  
 20228ec:	13 00 81 62 	sethi  %hi(0x2058800), %o1                     
 20228f0:	9f c6 40 00 	call  %i1                                      
 20228f4:	92 12 61 40 	or  %o1, 0x140, %o1	! 2058940 <RTEMS_BDPART_MBR_MASTER_TYPE+0x410>
"    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 );   
 20228f8:	11 00 80 89 	sethi  %hi(0x2022400), %o0                     
 20228fc:	40 00 10 96 	call  2026b54 <rtems_iterate_over_all_threads> 
 2022900:	90 12 20 b8 	or  %o0, 0xb8, %o0	! 20224b8 <Stack_check_Dump_threads_usage>
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    /* dump interrupt stack info if any */                            
    Stack_check_Dump_threads_usage((Thread_Control *) -1);            
 2022904:	7f ff fe ed 	call  20224b8 <Stack_check_Dump_threads_usage> 
 2022908:	90 10 3f ff 	mov  -1, %o0                                   
  #endif                                                              
                                                                      
  print_context = NULL;                                               
 202290c:	c0 27 20 a4 	clr  [ %i4 + 0xa4 ]                            
  print_handler = NULL;                                               
 2022910:	c0 27 60 a8 	clr  [ %i5 + 0xa8 ]                            
 2022914:	81 c7 e0 08 	ret                                            
 2022918:	81 e8 00 00 	restore                                        
                                                                      

020227c0 <rtems_stack_checker_switch_extension>: */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) {
 20227c0:	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);                  
 20227c4:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
      return false;                                                   
 20227c8:	ba 10 20 00 	clr  %i5                                       
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
 20227cc:	80 a7 80 01 	cmp  %fp, %g1                                  
 20227d0:	0a 80 00 06 	bcs  20227e8 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
 20227d4:	90 00 60 08 	add  %g1, 8, %o0                               
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
 20227d8:	c4 06 20 b4 	ld  [ %i0 + 0xb4 ], %g2                        
 20227dc:	82 00 40 02 	add  %g1, %g2, %g1                             
 20227e0:	80 a0 40 1e 	cmp  %g1, %fp                                  
 20227e4:	ba 60 3f ff 	subx  %g0, -1, %i5                             
  /*                                                                  
   *  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,                                     
 20227e8:	13 00 81 8a 	sethi  %hi(0x2062800), %o1                     
 20227ec:	94 10 20 10 	mov  0x10, %o2                                 
 20227f0:	40 00 5d be 	call  2039ee8 <memcmp>                         
 20227f4:	92 12 62 8c 	or  %o1, 0x28c, %o1                            
 20227f8:	80 a0 00 08 	cmp  %g0, %o0                                  
 20227fc:	82 60 3f ff 	subx  %g0, -1, %g1                             
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
 2022800:	80 a0 60 00 	cmp  %g1, 0                                    
 2022804:	02 80 00 06 	be  202281c <rtems_stack_checker_switch_extension+0x5c>
 2022808:	92 10 00 01 	mov  %g1, %o1                                  
 202280c:	ba 1f 60 01 	xor  %i5, 1, %i5                               
 2022810:	80 8f 60 ff 	btst  0xff, %i5                                
 2022814:	02 80 00 05 	be  2022828 <rtems_stack_checker_switch_extension+0x68><== ALWAYS TAKEN
 2022818:	01 00 00 00 	nop                                            
    Stack_check_report_blown_task( running, pattern_ok );             
 202281c:	90 10 00 18 	mov  %i0, %o0                                  
 2022820:	7f ff ff bc 	call  2022710 <Stack_check_report_blown_task>  
 2022824:	92 0a 60 01 	and  %o1, 1, %o1                               
 2022828:	81 c7 e0 08 	ret                                            
 202282c:	81 e8 00 00 	restore                                        
                                                                      

0201d66c <rtems_string_to_int>: const char *s, int *n, char **endptr, int base ) {
 201d66c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 201d670:	80 a6 60 00 	cmp  %i1, 0                                    
 201d674:	02 80 00 25 	be  201d708 <rtems_string_to_int+0x9c>         
 201d678:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 201d67c:	40 00 64 f6 	call  2036a54 <__errno>                        
 201d680:	01 00 00 00 	nop                                            
 201d684:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 201d688:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtol( s, &end, base );                                   
 201d68c:	90 10 00 18 	mov  %i0, %o0                                  
 201d690:	92 07 bf fc 	add  %fp, -4, %o1                              
 201d694:	40 00 85 ec 	call  203ee44 <strtol>                         
 201d698:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 201d69c:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
 201d6a0:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( endptr )                                                       
 201d6a4:	02 80 00 03 	be  201d6b0 <rtems_string_to_int+0x44>         
 201d6a8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 201d6ac:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 201d6b0:	80 a0 80 18 	cmp  %g2, %i0                                  
 201d6b4:	02 80 00 15 	be  201d708 <rtems_string_to_int+0x9c>         
 201d6b8:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 201d6bc:	40 00 64 e6 	call  2036a54 <__errno>                        
 201d6c0:	01 00 00 00 	nop                                            
 201d6c4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 201d6c8:	80 a0 60 22 	cmp  %g1, 0x22                                 
 201d6cc:	32 80 00 0e 	bne,a   201d704 <rtems_string_to_int+0x98>     
 201d6d0:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
 201d6d4:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
 201d6d8:	82 38 40 1d 	xnor  %g1, %i5, %g1                            
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 201d6dc:	80 a0 60 00 	cmp  %g1, 0                                    
 201d6e0:	02 80 00 0a 	be  201d708 <rtems_string_to_int+0x9c>         
 201d6e4:	82 10 20 0a 	mov  0xa, %g1                                  
 201d6e8:	80 a7 60 00 	cmp  %i5, 0                                    
 201d6ec:	02 80 00 07 	be  201d708 <rtems_string_to_int+0x9c>         <== NEVER TAKEN
 201d6f0:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
 201d6f4:	80 a7 40 02 	cmp  %i5, %g2                                  
 201d6f8:	02 80 00 04 	be  201d708 <rtems_string_to_int+0x9c>         <== ALWAYS TAKEN
 201d6fc:	01 00 00 00 	nop                                            
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
 201d700:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 201d704:	82 10 20 00 	clr  %g1                                       
}                                                                     
 201d708:	81 c7 e0 08 	ret                                            
 201d70c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200d970 <rtems_string_to_long>: const char *s, long *n, char **endptr, int base ) {
 200d970:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 200d974:	80 a6 60 00 	cmp  %i1, 0                                    
 200d978:	02 80 00 25 	be  200da0c <rtems_string_to_long+0x9c>        
 200d97c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 200d980:	40 00 0b 63 	call  201070c <__errno>                        
 200d984:	01 00 00 00 	nop                                            
 200d988:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 200d98c:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtol( s, &end, base );                                   
 200d990:	90 10 00 18 	mov  %i0, %o0                                  
 200d994:	92 07 bf fc 	add  %fp, -4, %o1                              
 200d998:	40 00 17 1a 	call  2013600 <strtol>                         
 200d99c:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 200d9a0:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
 200d9a4:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( endptr )                                                       
 200d9a8:	02 80 00 03 	be  200d9b4 <rtems_string_to_long+0x44>        
 200d9ac:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 200d9b0:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 200d9b4:	80 a0 80 18 	cmp  %g2, %i0                                  
 200d9b8:	02 80 00 15 	be  200da0c <rtems_string_to_long+0x9c>        
 200d9bc:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200d9c0:	40 00 0b 53 	call  201070c <__errno>                        
 200d9c4:	01 00 00 00 	nop                                            
 200d9c8:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 200d9cc:	80 a0 60 22 	cmp  %g1, 0x22                                 
 200d9d0:	32 80 00 0e 	bne,a   200da08 <rtems_string_to_long+0x98>    
 200d9d4:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
 200d9d8:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
 200d9dc:	82 38 40 1d 	xnor  %g1, %i5, %g1                            
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200d9e0:	80 a0 60 00 	cmp  %g1, 0                                    
 200d9e4:	02 80 00 0a 	be  200da0c <rtems_string_to_long+0x9c>        
 200d9e8:	82 10 20 0a 	mov  0xa, %g1                                  
 200d9ec:	80 a7 60 00 	cmp  %i5, 0                                    
 200d9f0:	02 80 00 07 	be  200da0c <rtems_string_to_long+0x9c>        <== NEVER TAKEN
 200d9f4:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
 200d9f8:	80 a7 40 02 	cmp  %i5, %g2                                  
 200d9fc:	02 80 00 04 	be  200da0c <rtems_string_to_long+0x9c>        <== ALWAYS TAKEN
 200da00:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
 200da04:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200da08:	82 10 20 00 	clr  %g1                                       
}                                                                     
 200da0c:	81 c7 e0 08 	ret                                            
 200da10:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200d8a4 <rtems_string_to_long_long>: const char *s, long long *n, char **endptr, int base ) {
 200d8a4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long long result;                                                   
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 200d8a8:	80 a6 60 00 	cmp  %i1, 0                                    
 200d8ac:	02 80 00 2f 	be  200d968 <rtems_string_to_long_long+0xc4>   
 200d8b0:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 200d8b4:	40 00 0b 96 	call  201070c <__errno>                        
 200d8b8:	01 00 00 00 	nop                                            
 200d8bc:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 200d8c0:	c0 26 40 00 	clr  [ %i1 ]                                   
 200d8c4:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtoll( s, &end, base );                                  
 200d8c8:	90 10 00 18 	mov  %i0, %o0                                  
 200d8cc:	92 07 bf fc 	add  %fp, -4, %o1                              
 200d8d0:	40 00 17 55 	call  2013624 <strtoll>                        
 200d8d4:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 200d8d8:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoll( s, &end, base );                                  
 200d8dc:	b8 10 00 08 	mov  %o0, %i4                                  
 200d8e0:	ba 10 00 09 	mov  %o1, %i5                                  
                                                                      
  if ( endptr )                                                       
 200d8e4:	02 80 00 03 	be  200d8f0 <rtems_string_to_long_long+0x4c>   
 200d8e8:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 200d8ec:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 200d8f0:	80 a0 80 18 	cmp  %g2, %i0                                  
 200d8f4:	02 80 00 1d 	be  200d968 <rtems_string_to_long_long+0xc4>   
 200d8f8:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200d8fc:	40 00 0b 84 	call  201070c <__errno>                        
 200d900:	01 00 00 00 	nop                                            
 200d904:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 200d908:	80 a0 60 22 	cmp  %g1, 0x22                                 
 200d90c:	32 80 00 16 	bne,a   200d964 <rtems_string_to_long_long+0xc0>
 200d910:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
 200d914:	05 1f ff ff 	sethi  %hi(0x7ffffc00), %g2                    
 200d918:	07 3f ff ff 	sethi  %hi(0xfffffc00), %g3                    
 200d91c:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
 200d920:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
 200d924:	84 1f 00 02 	xor  %i4, %g2, %g2                             
 200d928:	86 1f 40 03 	xor  %i5, %g3, %g3                             
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200d92c:	80 90 80 03 	orcc  %g2, %g3, %g0                            
 200d930:	02 80 00 0e 	be  200d968 <rtems_string_to_long_long+0xc4>   
 200d934:	82 10 20 0a 	mov  0xa, %g1                                  
 200d938:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
 200d93c:	02 80 00 0b 	be  200d968 <rtems_string_to_long_long+0xc4>   <== NEVER TAKEN
 200d940:	01 00 00 00 	nop                                            
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
 200d944:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
 200d948:	80 a7 00 01 	cmp  %i4, %g1                                  
 200d94c:	32 80 00 06 	bne,a   200d964 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
 200d950:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
 200d954:	80 a7 60 00 	cmp  %i5, 0                                    
 200d958:	22 80 00 04 	be,a   200d968 <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
 200d95c:	82 10 20 0a 	mov  0xa, %g1                                  
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
 200d960:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
 200d964:	82 10 20 00 	clr  %g1                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 200d968:	81 c7 e0 08 	ret                                            
 200d96c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0201d720 <rtems_string_to_unsigned_char>: const char *s, unsigned char *n, char **endptr, int base ) {
 201d720:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 201d724:	80 a6 60 00 	cmp  %i1, 0                                    
 201d728:	02 80 00 26 	be  201d7c0 <rtems_string_to_unsigned_char+0xa0>
 201d72c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 201d730:	40 00 64 c9 	call  2036a54 <__errno>                        
 201d734:	01 00 00 00 	nop                                            
 201d738:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 201d73c:	c0 2e 40 00 	clrb  [ %i1 ]                                  
                                                                      
  result = strtoul( s, &end, base );                                  
 201d740:	90 10 00 18 	mov  %i0, %o0                                  
 201d744:	92 07 bf fc 	add  %fp, -4, %o1                              
 201d748:	40 00 87 0d 	call  203f37c <strtoul>                        
 201d74c:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 201d750:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
 201d754:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( endptr )                                                       
 201d758:	02 80 00 03 	be  201d764 <rtems_string_to_unsigned_char+0x44>
 201d75c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 201d760:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 201d764:	80 a0 80 18 	cmp  %g2, %i0                                  
 201d768:	02 80 00 16 	be  201d7c0 <rtems_string_to_unsigned_char+0xa0>
 201d76c:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 201d770:	40 00 64 b9 	call  2036a54 <__errno>                        
 201d774:	01 00 00 00 	nop                                            
 201d778:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 201d77c:	80 a0 60 22 	cmp  %g1, 0x22                                 
 201d780:	12 80 00 07 	bne  201d79c <rtems_string_to_unsigned_char+0x7c>
 201d784:	80 a7 60 ff 	cmp  %i5, 0xff                                 
    (( result == 0 ) || ( result == ULONG_MAX )))                     
 201d788:	84 07 7f ff 	add  %i5, -1, %g2                              
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 201d78c:	80 a0 bf fd 	cmp  %g2, -3                                   
 201d790:	18 80 00 0c 	bgu  201d7c0 <rtems_string_to_unsigned_char+0xa0><== ALWAYS TAKEN
 201d794:	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 ) {                                         
 201d798:	80 a7 60 ff 	cmp  %i5, 0xff                                 <== NOT EXECUTED
 201d79c:	28 80 00 08 	bleu,a   201d7bc <rtems_string_to_unsigned_char+0x9c>
 201d7a0:	fa 2e 40 00 	stb  %i5, [ %i1 ]                              
    errno = ERANGE;                                                   
 201d7a4:	40 00 64 ac 	call  2036a54 <__errno>                        
 201d7a8:	01 00 00 00 	nop                                            
 201d7ac:	82 10 20 22 	mov  0x22, %g1	! 22 <PROM_START+0x22>          
 201d7b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return RTEMS_INVALID_NUMBER;                                      
 201d7b4:	10 80 00 03 	b  201d7c0 <rtems_string_to_unsigned_char+0xa0>
 201d7b8:	82 10 20 0a 	mov  0xa, %g1                                  
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 201d7bc:	82 10 20 00 	clr  %g1                                       
}                                                                     
 201d7c0:	81 c7 e0 08 	ret                                            
 201d7c4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200dacc <rtems_string_to_unsigned_int>: const char *s, unsigned int *n, char **endptr, int base ) {
 200dacc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 200dad0:	80 a6 60 00 	cmp  %i1, 0                                    
 200dad4:	02 80 00 1e 	be  200db4c <rtems_string_to_unsigned_int+0x80>
 200dad8:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 200dadc:	40 00 0b 0c 	call  201070c <__errno>                        
 200dae0:	01 00 00 00 	nop                                            
 200dae4:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 200dae8:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtoul( s, &end, base );                                  
 200daec:	90 10 00 18 	mov  %i0, %o0                                  
 200daf0:	92 07 bf fc 	add  %fp, -4, %o1                              
 200daf4:	40 00 18 11 	call  2013b38 <strtoul>                        
 200daf8:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 200dafc:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
 200db00:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( endptr )                                                       
 200db04:	02 80 00 03 	be  200db10 <rtems_string_to_unsigned_int+0x44>
 200db08:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 200db0c:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 200db10:	80 a0 80 18 	cmp  %g2, %i0                                  
 200db14:	02 80 00 0e 	be  200db4c <rtems_string_to_unsigned_int+0x80>
 200db18:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200db1c:	40 00 0a fc 	call  201070c <__errno>                        
 200db20:	01 00 00 00 	nop                                            
 200db24:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 200db28:	80 a0 60 22 	cmp  %g1, 0x22                                 
 200db2c:	32 80 00 07 	bne,a   200db48 <rtems_string_to_unsigned_int+0x7c>
 200db30:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    (( result == 0 ) || ( result == ULONG_MAX )))                     
 200db34:	84 07 7f ff 	add  %i5, -1, %g2                              
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200db38:	80 a0 bf fd 	cmp  %g2, -3                                   
 200db3c:	18 80 00 04 	bgu  200db4c <rtems_string_to_unsigned_int+0x80><== ALWAYS TAKEN
 200db40:	82 10 20 0a 	mov  0xa, %g1                                  
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
 200db44:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200db48:	82 10 20 00 	clr  %g1                                       
}                                                                     
 200db4c:	81 c7 e0 08 	ret                                            
 200db50:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200ba40 <rtems_string_to_unsigned_long>: const char *s, unsigned long *n, char **endptr, int base ) {
 200ba40:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 200ba44:	80 a6 60 00 	cmp  %i1, 0                                    
 200ba48:	02 80 00 1e 	be  200bac0 <rtems_string_to_unsigned_long+0x80>
 200ba4c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 200ba50:	40 00 ac 01 	call  2036a54 <__errno>                        
 200ba54:	01 00 00 00 	nop                                            
 200ba58:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 200ba5c:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtoul( s, &end, base );                                  
 200ba60:	90 10 00 18 	mov  %i0, %o0                                  
 200ba64:	92 07 bf fc 	add  %fp, -4, %o1                              
 200ba68:	40 00 ce 45 	call  203f37c <strtoul>                        
 200ba6c:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 200ba70:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
 200ba74:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( endptr )                                                       
 200ba78:	02 80 00 03 	be  200ba84 <rtems_string_to_unsigned_long+0x44>
 200ba7c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 200ba80:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 200ba84:	80 a0 80 18 	cmp  %g2, %i0                                  
 200ba88:	02 80 00 0e 	be  200bac0 <rtems_string_to_unsigned_long+0x80>
 200ba8c:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200ba90:	40 00 ab f1 	call  2036a54 <__errno>                        
 200ba94:	01 00 00 00 	nop                                            
 200ba98:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 200ba9c:	80 a0 60 22 	cmp  %g1, 0x22                                 
 200baa0:	32 80 00 07 	bne,a   200babc <rtems_string_to_unsigned_long+0x7c>
 200baa4:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    (( result == 0 ) || ( result == ULONG_MAX )))                     
 200baa8:	84 07 7f ff 	add  %i5, -1, %g2                              
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200baac:	80 a0 bf fd 	cmp  %g2, -3                                   
 200bab0:	18 80 00 04 	bgu  200bac0 <rtems_string_to_unsigned_long+0x80><== ALWAYS TAKEN
 200bab4:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
 200bab8:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200babc:	82 10 20 00 	clr  %g1                                       
}                                                                     
 200bac0:	81 c7 e0 08 	ret                                            
 200bac4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200db54 <rtems_string_to_unsigned_long_long>: const char *s, unsigned long long *n, char **endptr, int base ) {
 200db54:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long long result;                                          
  char *end;                                                          
                                                                      
  if ( !n )                                                           
 200db58:	80 a6 60 00 	cmp  %i1, 0                                    
 200db5c:	02 80 00 23 	be  200dbe8 <rtems_string_to_unsigned_long_long+0x94>
 200db60:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
 200db64:	40 00 0a ea 	call  201070c <__errno>                        
 200db68:	01 00 00 00 	nop                                            
 200db6c:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
 200db70:	c0 26 40 00 	clr  [ %i1 ]                                   
 200db74:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtoull( s, &end, base );                                 
 200db78:	90 10 00 18 	mov  %i0, %o0                                  
 200db7c:	92 07 bf fc 	add  %fp, -4, %o1                              
 200db80:	40 00 17 f7 	call  2013b5c <strtoull>                       
 200db84:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
 200db88:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoull( s, &end, base );                                 
 200db8c:	b8 10 00 08 	mov  %o0, %i4                                  
 200db90:	ba 10 00 09 	mov  %o1, %i5                                  
                                                                      
  if ( endptr )                                                       
 200db94:	02 80 00 03 	be  200dba0 <rtems_string_to_unsigned_long_long+0x4c>
 200db98:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    *endptr = end;                                                    
 200db9c:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
 200dba0:	80 a0 80 18 	cmp  %g2, %i0                                  
 200dba4:	02 80 00 11 	be  200dbe8 <rtems_string_to_unsigned_long_long+0x94>
 200dba8:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200dbac:	40 00 0a d8 	call  201070c <__errno>                        
 200dbb0:	01 00 00 00 	nop                                            
 200dbb4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
 200dbb8:	80 a0 60 22 	cmp  %g1, 0x22                                 
 200dbbc:	32 80 00 0a 	bne,a   200dbe4 <rtems_string_to_unsigned_long_long+0x90>
 200dbc0:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
 200dbc4:	86 87 7f ff 	addcc  %i5, -1, %g3                            
 200dbc8:	84 47 3f ff 	addx  %i4, -1, %g2                             
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
 200dbcc:	80 a0 bf ff 	cmp  %g2, -1                                   
 200dbd0:	12 80 00 04 	bne  200dbe0 <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
 200dbd4:	80 a0 ff fd 	cmp  %g3, -3                                   
 200dbd8:	18 80 00 04 	bgu  200dbe8 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
 200dbdc:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
 200dbe0:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 200dbe4:	82 10 20 00 	clr  %g1                                       
}                                                                     
 200dbe8:	81 c7 e0 08 	ret                                            
 200dbec:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02002ee4 <rtems_tarfs_load>: int rtems_tarfs_load( const char *mountpoint, uint8_t *tar_image, size_t tar_size ) {
 2002ee4:	9d e3 bd e8 	save  %sp, -536, %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 =                     
 2002ee8:	94 10 20 18 	mov  0x18, %o2                                 
 2002eec:	92 10 00 18 	mov  %i0, %o1                                  
 2002ef0:	40 00 07 ed 	call  2004ea4 <rtems_filesystem_eval_path_start>
 2002ef4:	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(                          
 2002ef8:	92 07 be 78 	add  %fp, -392, %o1                            
 2002efc:	b6 10 00 08 	mov  %o0, %i3                                  
 2002f00:	40 00 08 e3 	call  200528c <rtems_filesystem_location_copy_and_detach>
 2002f04:	90 07 be 48 	add  %fp, -440, %o0                            
static inline void rtems_filesystem_eval_path_set_flags(              
  rtems_filesystem_eval_path_context_t *ctx,                          
  int flags                                                           
)                                                                     
{                                                                     
  ctx->flags = flags;                                                 
 2002f08:	82 10 20 60 	mov  0x60, %g1                                 
 2002f0c:	c2 27 be 70 	st  %g1, [ %fp + -400 ]                        
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
 2002f10:	c2 07 be 5c 	ld  [ %fp + -420 ], %g1                        
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
 2002f14:	05 00 80 7d 	sethi  %hi(0x201f400), %g2                     
     rootloc.mt_entry->ops != &IMFS_ops                               
 2002f18:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
 2002f1c:	84 10 a2 10 	or  %g2, 0x210, %g2                            
 2002f20:	80 a0 40 02 	cmp  %g1, %g2                                  
 2002f24:	02 80 00 06 	be  2002f3c <rtems_tarfs_load+0x58>            
 2002f28:	05 00 80 7f 	sethi  %hi(0x201fc00), %g2                     
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
 2002f2c:	84 10 a3 80 	or  %g2, 0x380, %g2	! 201ff80 <fifoIMFS_ops>   
 2002f30:	80 a0 40 02 	cmp  %g1, %g2                                  
 2002f34:	32 80 00 66 	bne,a   20030cc <rtems_tarfs_load+0x1e8>       <== ALWAYS TAKEN
 2002f38:	b0 10 3f ff 	mov  -1, %i0                                   
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
 2002f3c:	25 00 80 7d 	sethi  %hi(0x201f400), %l2                     
        filename,                                                     
        strlen( filename )                                            
      );                                                              
      rtems_filesystem_eval_path_continue( &ctx );                    
                                                                      
      if ( !rtems_filesystem_location_is_null( currentloc ) ) {       
 2002f40:	27 00 80 7f 	sethi  %hi(0x201fc00), %l3                     
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
      if (full_filename[strlen(full_filename)-1] != '/')              
        strcat(full_filename, "/");                                   
 2002f44:	29 00 80 71 	sethi  %hi(0x201c400), %l4                     
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
 2002f48:	ba 10 20 00 	clr  %i5                                       
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
 2002f4c:	a4 14 a2 98 	or  %l2, 0x298, %l2                            
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
 2002f50:	a0 07 be 98 	add  %fp, -360, %l0                            
        filename,                                                     
        strlen( filename )                                            
      );                                                              
      rtems_filesystem_eval_path_continue( &ctx );                    
                                                                      
      if ( !rtems_filesystem_location_is_null( currentloc ) ) {       
 2002f54:	a6 14 e0 dc 	or  %l3, 0xdc, %l3                             
     * - For files, create a file node with special tarfs properties. 
     */                                                               
    if (linkflag == DIRTYPE) {                                        
      strcpy(full_filename, mountpoint);                              
      if (full_filename[strlen(full_filename)-1] != '/')              
        strcat(full_filename, "/");                                   
 2002f58:	a8 15 21 f0 	or  %l4, 0x1f0, %l4                            
   /*                                                                 
    * Create an IMFS node structure pointing to tar image memory.     
    */                                                                
   offset = 0;                                                        
   while ( rv == 0 ) {                                                
    if (offset + 512 > tar_size)                                      
 2002f5c:	b8 07 62 00 	add  %i5, 0x200, %i4                           
 2002f60:	80 a7 00 1a 	cmp  %i4, %i2                                  
 2002f64:	18 80 00 59 	bgu  20030c8 <rtems_tarfs_load+0x1e4>          <== NEVER TAKEN
 2002f68:	ba 06 40 1d 	add  %i1, %i5, %i5                             
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
 2002f6c:	92 10 00 12 	mov  %l2, %o1                                  
 2002f70:	90 07 61 01 	add  %i5, 0x101, %o0                           
 2002f74:	40 00 43 8a 	call  2013d9c <strncmp>                        
 2002f78:	94 10 20 05 	mov  5, %o2                                    
 2002f7c:	80 a2 20 00 	cmp  %o0, 0                                    
 2002f80:	12 80 00 52 	bne  20030c8 <rtems_tarfs_load+0x1e4>          
 2002f84:	94 10 20 63 	mov  0x63, %o2                                 
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
 2002f88:	92 10 00 1d 	mov  %i5, %o1                                  
 2002f8c:	40 00 43 da 	call  2013ef4 <strncpy>                        
 2002f90:	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);                
 2002f94:	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';                             
 2002f98:	c0 2f be fb 	clrb  [ %fp + -261 ]                           
                                                                      
    linkflag   = hdr_ptr[156];                                        
 2002f9c:	ec 0f 60 9c 	ldub  [ %i5 + 0x9c ], %l6                      
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
 2002fa0:	40 00 21 c5 	call  200b6b4 <_rtems_octal2ulong>             
 2002fa4:	90 07 60 64 	add  %i5, 0x64, %o0                            
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
 2002fa8:	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);                
 2002fac:	aa 10 00 08 	mov  %o0, %l5                                  
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
 2002fb0:	40 00 21 c1 	call  200b6b4 <_rtems_octal2ulong>             
 2002fb4:	90 07 60 7c 	add  %i5, 0x7c, %o0                            
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
 2002fb8:	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);               
 2002fbc:	a2 10 00 08 	mov  %o0, %l1                                  
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
 2002fc0:	40 00 21 bd 	call  200b6b4 <_rtems_octal2ulong>             
 2002fc4:	90 07 60 94 	add  %i5, 0x94, %o0                            
 2002fc8:	ae 10 00 08 	mov  %o0, %l7                                  
                                                                      
    if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)            
 2002fcc:	40 00 21 cd 	call  200b700 <_rtems_tar_header_checksum>     
 2002fd0:	90 10 00 1d 	mov  %i5, %o0                                  
 2002fd4:	80 a2 00 17 	cmp  %o0, %l7                                  
 2002fd8:	12 80 00 3c 	bne  20030c8 <rtems_tarfs_load+0x1e4>          <== NEVER TAKEN
 2002fdc:	82 0d a0 ff 	and  %l6, 0xff, %g1                            
     * 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) {                                        
 2002fe0:	80 a0 60 35 	cmp  %g1, 0x35                                 
 2002fe4:	12 80 00 16 	bne  200303c <rtems_tarfs_load+0x158>          
 2002fe8:	80 a0 60 30 	cmp  %g1, 0x30                                 
      strcpy(full_filename, mountpoint);                              
 2002fec:	92 10 00 18 	mov  %i0, %o1                                  
 2002ff0:	40 00 41 77 	call  20135cc <strcpy>                         
 2002ff4:	90 07 bf 00 	add  %fp, -256, %o0                            
      if (full_filename[strlen(full_filename)-1] != '/')              
 2002ff8:	40 00 43 37 	call  2013cd4 <strlen>                         
 2002ffc:	90 07 bf 00 	add  %fp, -256, %o0                            
 2003000:	90 07 80 08 	add  %fp, %o0, %o0                             
 2003004:	c2 4a 3e ff 	ldsb  [ %o0 + -257 ], %g1                      
 2003008:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
 200300c:	02 80 00 04 	be  200301c <rtems_tarfs_load+0x138>           <== ALWAYS TAKEN
 2003010:	90 07 bf 00 	add  %fp, -256, %o0                            
        strcat(full_filename, "/");                                   
 2003014:	40 00 41 1d 	call  2013488 <strcat>                         <== NOT EXECUTED
 2003018:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
      strcat(full_filename, filename);                                
 200301c:	92 10 00 10 	mov  %l0, %o1                                  
 2003020:	40 00 41 1a 	call  2013488 <strcat>                         
 2003024:	90 07 bf 00 	add  %fp, -256, %o0                            
      mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);              
 2003028:	90 07 bf 00 	add  %fp, -256, %o0                            
 200302c:	40 00 03 dc 	call  2003f9c <mkdir>                          
 2003030:	92 10 21 ff 	mov  0x1ff, %o1                                
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
 2003034:	10 bf ff ca 	b  2002f5c <rtems_tarfs_load+0x78>             
 2003038:	ba 10 00 1c 	mov  %i4, %i5                                  
      mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);              
    }                                                                 
    /*                                                                
     * Create a LINEAR_FILE node                                      
     */                                                               
    else if (linkflag == REGTYPE) {                                   
 200303c:	12 bf ff c8 	bne  2002f5c <rtems_tarfs_load+0x78>           
 2003040:	ba 10 00 1c 	mov  %i4, %i5                                  
      rtems_filesystem_location_free( currentloc );                   
 2003044:	40 00 02 3f 	call  2003940 <rtems_filesystem_location_free> 
 2003048:	90 10 00 1b 	mov  %i3, %o0                                  
      rtems_filesystem_location_clone( currentloc, &rootloc );        
 200304c:	92 07 be 48 	add  %fp, -440, %o1                            
 2003050:	40 00 01 6d 	call  2003604 <rtems_filesystem_location_clone>
 2003054:	90 10 00 1b 	mov  %i3, %o0                                  
      rtems_filesystem_eval_path_set_path(                            
 2003058:	40 00 43 1f 	call  2013cd4 <strlen>                         
 200305c:	90 10 00 10 	mov  %l0, %o0                                  
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char *path,                                                   
  size_t pathlen                                                      
)                                                                     
{                                                                     
  ctx->path = path;                                                   
 2003060:	e0 27 be 60 	st  %l0, [ %fp + -416 ]                        
  ctx->pathlen = pathlen;                                             
 2003064:	d0 27 be 64 	st  %o0, [ %fp + -412 ]                        
        &ctx,                                                         
        filename,                                                     
        strlen( filename )                                            
      );                                                              
      rtems_filesystem_eval_path_continue( &ctx );                    
 2003068:	40 00 07 31 	call  2004d2c <rtems_filesystem_eval_path_continue>
 200306c:	90 07 be 60 	add  %fp, -416, %o0                            
                                                                      
      if ( !rtems_filesystem_location_is_null( currentloc ) ) {       
 2003070:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
 2003074:	80 a0 40 13 	cmp  %g1, %l3                                  
 2003078:	02 80 00 0f 	be  20030b4 <rtems_tarfs_load+0x1d0>           <== NEVER TAKEN
 200307c:	d4 1f be 68 	ldd  [ %fp + -408 ], %o2                       
  size_t namelen,                                                     
  mode_t mode,                                                        
  const IMFS_types_union *info                                        
)                                                                     
{                                                                     
  const IMFS_fs_info_t *fs_info =                                     
 2003080:	c2 06 e0 14 	ld  [ %i3 + 0x14 ], %g1                        
    (const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;            
                                                                      
  return IMFS_create_node_with_control(                               
 2003084:	c2 00 60 08 	ld  [ %g1 + 8 ], %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,      
 2003088:	98 0d 61 ff 	and  %l5, 0x1ff, %o4                           
 200308c:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
 2003090:	03 00 00 20 	sethi  %hi(0x8000), %g1                        
 2003094:	90 10 00 1b 	mov  %i3, %o0                                  
 2003098:	98 13 00 01 	or  %o4, %g1, %o4                              
 200309c:	40 00 23 32 	call  200bd64 <IMFS_create_node_with_control>  
 20030a0:	9a 10 20 00 	clr  %o5                                       
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
        node->info.linearfile.direct = &tar_image[offset];            
 20030a4:	84 06 40 1c 	add  %i1, %i4, %g2                             
          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;                     
 20030a8:	c0 22 20 50 	clr  [ %o0 + 0x50 ]                            
 20030ac:	e2 22 20 54 	st  %l1, [ %o0 + 0x54 ]                        
        node->info.linearfile.direct = &tar_image[offset];            
 20030b0:	c4 22 20 58 	st  %g2, [ %o0 + 0x58 ]                        
      }                                                               
                                                                      
      nblocks = (((file_size) + 511) & ~511) / 512;                   
 20030b4:	a2 04 61 ff 	add  %l1, 0x1ff, %l1                           
      offset += 512 * nblocks;                                        
 20030b8:	a2 0c 7e 00 	and  %l1, -512, %l1                            
 20030bc:	b8 04 40 1c 	add  %l1, %i4, %i4                             
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
 20030c0:	10 bf ff a7 	b  2002f5c <rtems_tarfs_load+0x78>             
 20030c4:	ba 10 00 1c 	mov  %i4, %i5                                  
    linkflag   = hdr_ptr[156];                                        
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
                                                                      
    if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)            
 20030c8:	b0 10 20 00 	clr  %i0                                       
      nblocks = (((file_size) + 511) & ~511) / 512;                   
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
 20030cc:	40 00 02 1d 	call  2003940 <rtems_filesystem_location_free> 
 20030d0:	90 07 be 48 	add  %fp, -440, %o0                            
  rtems_filesystem_eval_path_cleanup( &ctx );                         
 20030d4:	40 00 07 b0 	call  2004f94 <rtems_filesystem_eval_path_cleanup>
 20030d8:	90 07 be 60 	add  %fp, -416, %o0                            
                                                                      
  return rv;                                                          
}                                                                     
 20030dc:	81 c7 e0 08 	ret                                            
 20030e0:	81 e8 00 00 	restore                                        
                                                                      

020110fc <rtems_task_mode>: rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) {
 20110fc:	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 )                                           
 2011100:	80 a6 a0 00 	cmp  %i2, 0                                    
 2011104:	02 80 00 5a 	be  201126c <rtems_task_mode+0x170>            
 2011108:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
 201110c:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
 2011110:	f8 00 63 20 	ld  [ %g1 + 0x320 ], %i4	! 2021f20 <_Per_CPU_Information+0x10>
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
 2011114:	c2 0f 20 70 	ldub  [ %i4 + 0x70 ], %g1                      
                                                                      
  if ( !previous_mode_set )                                           
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
  api = executing->API_Extensions[ THREAD_API_RTEMS ];                
 2011118:	fa 07 21 58 	ld  [ %i4 + 0x158 ], %i5                       
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
 201111c:	80 a0 00 01 	cmp  %g0, %g1                                  
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
 2011120:	c2 07 20 78 	ld  [ %i4 + 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;
 2011124:	b6 60 3f ff 	subx  %g0, -1, %i3                             
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
 2011128:	80 a0 60 00 	cmp  %g1, 0                                    
 201112c:	02 80 00 03 	be  2011138 <rtems_task_mode+0x3c>             
 2011130:	b7 2e e0 08 	sll  %i3, 8, %i3                               
    old_mode |= RTEMS_NO_TIMESLICE;                                   
  else                                                                
    old_mode |= RTEMS_TIMESLICE;                                      
 2011134:	b6 16 e2 00 	or  %i3, 0x200, %i3                            
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
 2011138:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
 201113c:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
 2011140:	7f ff ed 22 	call  200c5c8 <_CPU_ISR_Get_level>             
 2011144:	a0 60 3f ff 	subx  %g0, -1, %l0                             
  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;           
 2011148:	a1 2c 20 0a 	sll  %l0, 0xa, %l0                             
 201114c:	90 14 00 08 	or  %l0, %o0, %o0                              
  old_mode |= _ISR_Get_level();                                       
 2011150:	b6 12 00 1b 	or  %o0, %i3, %i3                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
 2011154:	80 8e 61 00 	btst  0x100, %i1                               
 2011158:	02 80 00 06 	be  2011170 <rtems_task_mode+0x74>             
 201115c:	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;           
 2011160:	83 36 20 08 	srl  %i0, 8, %g1                               
 2011164:	82 18 60 01 	xor  %g1, 1, %g1                               
 2011168:	82 08 60 01 	and  %g1, 1, %g1                               
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
 201116c:	c2 2f 20 70 	stb  %g1, [ %i4 + 0x70 ]                       
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
 2011170:	80 8e 62 00 	btst  0x200, %i1                               
 2011174:	02 80 00 0b 	be  20111a0 <rtems_task_mode+0xa4>             
 2011178:	80 8e 60 0f 	btst  0xf, %i1                                 
    if ( _Modes_Is_timeslice(mode_set) ) {                            
 201117c:	80 8e 22 00 	btst  0x200, %i0                               
 2011180:	22 80 00 07 	be,a   201119c <rtems_task_mode+0xa0>          
 2011184:	c0 27 20 78 	clr  [ %i4 + 0x78 ]                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
 2011188:	82 10 20 01 	mov  1, %g1                                    
 201118c:	c2 27 20 78 	st  %g1, [ %i4 + 0x78 ]                        
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
 2011190:	03 00 80 86 	sethi  %hi(0x2021800), %g1                     
 2011194:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1	! 2021950 <_Thread_Ticks_per_timeslice>
 2011198:	c2 27 20 74 	st  %g1, [ %i4 + 0x74 ]                        
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
 201119c:	80 8e 60 0f 	btst  0xf, %i1                                 
 20111a0:	02 80 00 06 	be  20111b8 <rtems_task_mode+0xbc>             
 20111a4:	80 8e 64 00 	btst  0x400, %i1                               
 */                                                                   
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (           
  Modes_Control mode_set                                              
)                                                                     
{                                                                     
  return ( mode_set & RTEMS_INTERRUPT_MASK );                         
 20111a8:	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 ) );           
 20111ac:	7f ff c7 1c 	call  2002e1c <sparc_enable_interrupts>        
 20111b0:	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 ) {                                      
 20111b4:	80 8e 64 00 	btst  0x400, %i1                               
 20111b8:	02 80 00 14 	be  2011208 <rtems_task_mode+0x10c>            
 20111bc:	88 10 20 00 	clr  %g4                                       
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
 20111c0:	c2 0f 60 08 	ldub  [ %i5 + 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;
 20111c4:	b1 36 20 0a 	srl  %i0, 0xa, %i0                             
 20111c8:	b0 1e 20 01 	xor  %i0, 1, %i0                               
 20111cc:	b0 0e 20 01 	and  %i0, 1, %i0                               
    if ( is_asr_enabled != asr->is_enabled ) {                        
 20111d0:	80 a6 00 01 	cmp  %i0, %g1                                  
 20111d4:	22 80 00 0e 	be,a   201120c <rtems_task_mode+0x110>         
 20111d8:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
)                                                                     
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
 20111dc:	7f ff c7 0c 	call  2002e0c <sparc_disable_interrupts>       
 20111e0:	f0 2f 60 08 	stb  %i0, [ %i5 + 8 ]                          
    _signals                     = information->signals_pending;      
 20111e4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
    information->signals_pending = information->signals_posted;       
 20111e8:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
    information->signals_posted  = _signals;                          
 20111ec:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
    _signals                     = information->signals_pending;      
    information->signals_pending = information->signals_posted;       
 20111f0:	c4 27 60 18 	st  %g2, [ %i5 + 0x18 ]                        
    information->signals_posted  = _signals;                          
  _ISR_Enable( _level );                                              
 20111f4:	7f ff c7 0a 	call  2002e1c <sparc_enable_interrupts>        
 20111f8:	01 00 00 00 	nop                                            
      asr->is_enabled = is_asr_enabled;                               
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
 20111fc:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 2011200:	80 a0 00 01 	cmp  %g0, %g1                                  
 2011204:	88 40 20 00 	addx  %g0, 0, %g4                              
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
 2011208:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
 201120c:	c4 00 63 08 	ld  [ %g1 + 0x308 ], %g2	! 2021f08 <_System_state_Current>
 2011210:	80 a0 a0 03 	cmp  %g2, 3                                    
 2011214:	12 80 00 16 	bne  201126c <rtems_task_mode+0x170>           
 2011218:	82 10 20 00 	clr  %g1                                       
  bool are_signals_pending                                            
)                                                                     
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
 201121c:	07 00 80 87 	sethi  %hi(0x2021c00), %g3                     
                                                                      
  if ( are_signals_pending ||                                         
 2011220:	80 89 20 ff 	btst  0xff, %g4                                
  bool are_signals_pending                                            
)                                                                     
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
 2011224:	86 10 e3 10 	or  %g3, 0x310, %g3                            
                                                                      
  if ( are_signals_pending ||                                         
 2011228:	12 80 00 0a 	bne  2011250 <rtems_task_mode+0x154>           
 201122c:	c4 00 e0 10 	ld  [ %g3 + 0x10 ], %g2                        
 2011230:	c6 00 e0 14 	ld  [ %g3 + 0x14 ], %g3                        
 2011234:	80 a0 80 03 	cmp  %g2, %g3                                  
 2011238:	02 80 00 0d 	be  201126c <rtems_task_mode+0x170>            
 201123c:	01 00 00 00 	nop                                            
       (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
 2011240:	c4 08 a0 70 	ldub  [ %g2 + 0x70 ], %g2                      
 2011244:	80 a0 a0 00 	cmp  %g2, 0                                    
 2011248:	02 80 00 09 	be  201126c <rtems_task_mode+0x170>            <== NEVER TAKEN
 201124c:	01 00 00 00 	nop                                            
    _Thread_Dispatch_necessary = true;                                
 2011250:	84 10 20 01 	mov  1, %g2	! 1 <PROM_START+0x1>               
 2011254:	03 00 80 87 	sethi  %hi(0x2021c00), %g1                     
 2011258:	82 10 63 10 	or  %g1, 0x310, %g1	! 2021f10 <_Per_CPU_Information>
 201125c:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
 2011260:	40 00 02 6b 	call  2011c0c <_Thread_Dispatch>               
 2011264:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
 2011268:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
}                                                                     
 201126c:	81 c7 e0 08 	ret                                            
 2011270:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

0200bdf0 <rtems_task_set_priority>: rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) {
 200bdf0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
 200bdf4:	80 a6 60 00 	cmp  %i1, 0                                    
 200bdf8:	02 80 00 08 	be  200be18 <rtems_task_set_priority+0x28>     
 200bdfc:	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 ) );             
 200be00:	03 00 80 83 	sethi  %hi(0x2020c00), %g1                     
 200be04:	c4 08 63 8c 	ldub  [ %g1 + 0x38c ], %g2	! 2020f8c <rtems_maximum_priority>
 200be08:	80 a6 40 02 	cmp  %i1, %g2                                  
 200be0c:	18 80 00 1e 	bgu  200be84 <rtems_task_set_priority+0x94>    
 200be10:	82 10 20 13 	mov  0x13, %g1                                 
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
 200be14:	80 a6 a0 00 	cmp  %i2, 0                                    
 200be18:	02 80 00 1b 	be  200be84 <rtems_task_set_priority+0x94>     
 200be1c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
 200be20:	90 10 00 18 	mov  %i0, %o0                                  
 200be24:	40 00 09 a6 	call  200e4bc <_Thread_Get>                    
 200be28:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
 200be2c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 200be30:	80 a0 60 00 	cmp  %g1, 0                                    
 200be34:	12 80 00 14 	bne  200be84 <rtems_task_set_priority+0x94>    
 200be38:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
 200be3c:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
 200be40:	80 a6 60 00 	cmp  %i1, 0                                    
 200be44:	02 80 00 0d 	be  200be78 <rtems_task_set_priority+0x88>     
 200be48:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
 200be4c:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
 200be50:	80 a0 60 00 	cmp  %g1, 0                                    
 200be54:	02 80 00 06 	be  200be6c <rtems_task_set_priority+0x7c>     
 200be58:	f2 22 20 18 	st  %i1, [ %o0 + 0x18 ]                        
 200be5c:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
 200be60:	80 a0 40 19 	cmp  %g1, %i1                                  
 200be64:	08 80 00 05 	bleu  200be78 <rtems_task_set_priority+0x88>   <== ALWAYS TAKEN
 200be68:	01 00 00 00 	nop                                            
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
 200be6c:	92 10 00 19 	mov  %i1, %o1                                  
 200be70:	40 00 08 55 	call  200dfc4 <_Thread_Change_priority>        
 200be74:	94 10 20 00 	clr  %o2                                       
      }                                                               
      _Thread_Enable_dispatch();                                      
 200be78:	40 00 09 85 	call  200e48c <_Thread_Enable_dispatch>        
 200be7c:	01 00 00 00 	nop                                            
 200be80:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 200be84:	81 c7 e0 08 	ret                                            
 200be88:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02006258 <rtems_termios_baud_to_index>: #include <rtems/termiostypes.h> int rtems_termios_baud_to_index( rtems_termios_baud_t termios_baud ) {
 2006258:	82 10 00 08 	mov  %o0, %g1                                  
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
 200625c:	80 a0 60 09 	cmp  %g1, 9                                    
 2006260:	02 80 00 17 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 2006264:	90 10 20 09 	mov  9, %o0                                    
 2006268:	80 a0 60 09 	cmp  %g1, 9                                    
 200626c:	18 80 00 23 	bgu  20062f8 <rtems_termios_baud_to_index+0xa0>
 2006270:	80 a0 60 0e 	cmp  %g1, 0xe                                  
 2006274:	80 a0 60 04 	cmp  %g1, 4                                    
 2006278:	02 80 00 11 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 200627c:	90 10 20 04 	mov  4, %o0                                    
 2006280:	80 a0 60 04 	cmp  %g1, 4                                    
 2006284:	18 80 00 10 	bgu  20062c4 <rtems_termios_baud_to_index+0x6c>
 2006288:	80 a0 60 06 	cmp  %g1, 6                                    
 200628c:	80 a0 60 01 	cmp  %g1, 1                                    
 2006290:	02 80 00 0b 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 2006294:	90 10 20 01 	mov  1, %o0                                    
 2006298:	80 a0 60 01 	cmp  %g1, 1                                    
 200629c:	0a 80 00 08 	bcs  20062bc <rtems_termios_baud_to_index+0x64>
 20062a0:	90 10 20 00 	clr  %o0                                       
 20062a4:	80 a0 60 02 	cmp  %g1, 2                                    
 20062a8:	02 80 00 05 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 20062ac:	90 10 20 02 	mov  2, %o0                                    
 20062b0:	80 a0 60 03 	cmp  %g1, 3                                    
 20062b4:	12 80 00 3b 	bne  20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
 20062b8:	90 10 20 03 	mov  3, %o0                                    
 20062bc:	81 c3 e0 08 	retl                                           
 20062c0:	01 00 00 00 	nop                                            
 20062c4:	02 bf ff fe 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 20062c8:	90 10 20 06 	mov  6, %o0	! 6 <PROM_START+0x6>               
 20062cc:	80 a0 60 06 	cmp  %g1, 6                                    
 20062d0:	0a bf ff fb 	bcs  20062bc <rtems_termios_baud_to_index+0x64>
 20062d4:	90 10 20 05 	mov  5, %o0                                    
 20062d8:	80 a0 60 07 	cmp  %g1, 7                                    
 20062dc:	02 bf ff f8 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 20062e0:	90 10 20 07 	mov  7, %o0                                    
 20062e4:	80 a0 60 08 	cmp  %g1, 8                                    
 20062e8:	12 80 00 2e 	bne  20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
 20062ec:	90 10 20 08 	mov  8, %o0                                    
 20062f0:	81 c3 e0 08 	retl                                           
 20062f4:	01 00 00 00 	nop                                            
 20062f8:	02 bf ff f1 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 20062fc:	90 10 20 0e 	mov  0xe, %o0	! e <PROM_START+0xe>             
 2006300:	80 a0 60 0e 	cmp  %g1, 0xe                                  
 2006304:	18 80 00 10 	bgu  2006344 <rtems_termios_baud_to_index+0xec>
 2006308:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
 200630c:	80 a0 60 0b 	cmp  %g1, 0xb                                  
 2006310:	02 bf ff eb 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 2006314:	90 10 20 0b 	mov  0xb, %o0                                  
 2006318:	80 a0 60 0b 	cmp  %g1, 0xb                                  
 200631c:	0a bf ff e8 	bcs  20062bc <rtems_termios_baud_to_index+0x64>
 2006320:	90 10 20 0a 	mov  0xa, %o0                                  
 2006324:	80 a0 60 0c 	cmp  %g1, 0xc                                  
 2006328:	02 bf ff e5 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 200632c:	90 10 20 0c 	mov  0xc, %o0                                  
 2006330:	80 a0 60 0d 	cmp  %g1, 0xd                                  
 2006334:	12 80 00 1b 	bne  20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
 2006338:	90 10 20 0d 	mov  0xd, %o0                                  
 200633c:	81 c3 e0 08 	retl                                           
 2006340:	01 00 00 00 	nop                                            
 2006344:	86 10 a0 02 	or  %g2, 2, %g3                                
 2006348:	80 a0 40 03 	cmp  %g1, %g3                                  
 200634c:	02 bf ff dc 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 2006350:	90 10 20 11 	mov  0x11, %o0                                 
 2006354:	80 a0 40 03 	cmp  %g1, %g3                                  
 2006358:	38 80 00 0b 	bgu,a   2006384 <rtems_termios_baud_to_index+0x12c>
 200635c:	86 10 a0 03 	or  %g2, 3, %g3                                
 2006360:	80 a0 60 0f 	cmp  %g1, 0xf                                  
 2006364:	02 bf ff d6 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 2006368:	90 10 20 0f 	mov  0xf, %o0                                  
 200636c:	84 10 a0 01 	or  %g2, 1, %g2                                
 2006370:	80 a0 40 02 	cmp  %g1, %g2                                  
 2006374:	12 80 00 0b 	bne  20063a0 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
 2006378:	90 10 20 10 	mov  0x10, %o0                                 
 200637c:	81 c3 e0 08 	retl                                           
 2006380:	01 00 00 00 	nop                                            
 2006384:	80 a0 40 03 	cmp  %g1, %g3                                  
 2006388:	02 bf ff cd 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 200638c:	90 10 20 12 	mov  0x12, %o0                                 
 2006390:	84 10 a0 04 	or  %g2, 4, %g2                                
 2006394:	80 a0 40 02 	cmp  %g1, %g2                                  
 2006398:	02 bf ff c9 	be  20062bc <rtems_termios_baud_to_index+0x64> 
 200639c:	90 10 20 13 	mov  0x13, %o0                                 
    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;                          
 20063a0:	90 10 3f ff 	mov  -1, %o0                                   
  }                                                                   
                                                                      
  return baud_index;                                                  
}                                                                     
 20063a4:	81 c3 e0 08 	retl                                           
                                                                      

020055d4 <rtems_termios_close>: rtems_interrupt_enable (level); } rtems_status_code rtems_termios_close (void *arg) {
 20055d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
 20055d8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
 20055dc:	92 10 20 00 	clr  %o1                                       
                                                                      
rtems_status_code                                                     
rtems_termios_close (void *arg)                                       
{                                                                     
  rtems_libio_open_close_args_t *args = arg;                          
  struct rtems_termios_tty *tty = args->iop->data1;                   
 20055e0:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
 20055e4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20055e8:	d0 00 60 80 	ld  [ %g1 + 0x80 ], %o0	! 201d480 <rtems_termios_ttyMutex>
 20055ec:	40 00 08 36 	call  20076c4 <rtems_semaphore_obtain>         
 20055f0:	94 10 20 00 	clr  %o2                                       
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
 20055f4:	80 a2 20 00 	cmp  %o0, 0                                    
 20055f8:	22 80 00 03 	be,a   2005604 <rtems_termios_close+0x30>      <== ALWAYS TAKEN
 20055fc:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 2005600:	30 80 00 30 	b,a   20056c0 <rtems_termios_close+0xec>       <== NOT EXECUTED
    rtems_fatal_error_occurred (sc);                                  
  if (--tty->refcount == 0) {                                         
 2005604:	82 00 7f ff 	add  %g1, -1, %g1                              
 2005608:	80 a0 60 00 	cmp  %g1, 0                                    
 200560c:	12 80 00 64 	bne  200579c <rtems_termios_close+0x1c8>       
 2005610:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
 2005614:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
 2005618:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 200561c:	85 28 a0 05 	sll  %g2, 5, %g2                               
 2005620:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
 2005624:	82 00 40 02 	add  %g1, %g2, %g1                             
 2005628:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 200562c:	80 a0 60 00 	cmp  %g1, 0                                    
 2005630:	22 80 00 06 	be,a   2005648 <rtems_termios_close+0x74>      
 2005634:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
      /*                                                              
       * call discipline-specific close                               
       */                                                             
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
 2005638:	9f c0 40 00 	call  %g1                                      
 200563c:	90 10 00 1d 	mov  %i5, %o0                                  
      }                                                               
      drainOutput (tty);                                              
      rtems_semaphore_release (tty->osem);                            
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
 2005640:	10 80 00 11 	b  2005684 <rtems_termios_close+0xb0>          
 2005644:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
      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);
 2005648:	92 10 20 00 	clr  %o1                                       
 200564c:	40 00 08 1e 	call  20076c4 <rtems_semaphore_obtain>         
 2005650:	94 10 20 00 	clr  %o2                                       
      if (sc != RTEMS_SUCCESSFUL) {                                   
 2005654:	80 a2 20 00 	cmp  %o0, 0                                    
 2005658:	22 80 00 03 	be,a   2005664 <rtems_termios_close+0x90>      <== ALWAYS TAKEN
 200565c:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2005660:	30 80 00 18 	b,a   20056c0 <rtems_termios_close+0xec>       <== NOT EXECUTED
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
 2005664:	80 a0 60 00 	cmp  %g1, 0                                    
 2005668:	02 80 00 04 	be  2005678 <rtems_termios_close+0xa4>         
 200566c:	01 00 00 00 	nop                                            
 2005670:	7f ff fe ad 	call  2005124 <drainOutput.part.0>             
 2005674:	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);                            
 2005678:	40 00 08 5c 	call  20077e8 <rtems_semaphore_release>        
 200567c:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
 2005680:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2005684:	80 a0 60 02 	cmp  %g1, 2                                    
 2005688:	32 80 00 10 	bne,a   20056c8 <rtems_termios_close+0xf4>     
 200568c:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
      /*                                                              
       * send "terminate" to I/O tasks                                
       */                                                             
      sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
 2005690:	d0 07 60 c4 	ld  [ %i5 + 0xc4 ], %o0                        
 2005694:	40 00 06 df 	call  2007210 <rtems_event_send>               
 2005698:	92 10 20 01 	mov  1, %o1                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
 200569c:	80 a2 20 00 	cmp  %o0, 0                                    
 20056a0:	22 80 00 03 	be,a   20056ac <rtems_termios_close+0xd8>      <== ALWAYS TAKEN
 20056a4:	d0 07 60 c8 	ld  [ %i5 + 0xc8 ], %o0                        
 20056a8:	30 80 00 06 	b,a   20056c0 <rtems_termios_close+0xec>       <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
 20056ac:	40 00 06 d9 	call  2007210 <rtems_event_send>               
 20056b0:	92 10 20 01 	mov  1, %o1                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
 20056b4:	80 a2 20 00 	cmp  %o0, 0                                    
 20056b8:	22 80 00 04 	be,a   20056c8 <rtems_termios_close+0xf4>      <== ALWAYS TAKEN
 20056bc:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
        rtems_fatal_error_occurred (sc);                              
 20056c0:	40 00 09 de 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 20056c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
    }                                                                 
    if (tty->device.lastClose)                                        
 20056c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20056cc:	22 80 00 07 	be,a   20056e8 <rtems_termios_close+0x114>     <== ALWAYS TAKEN
 20056d0:	c4 07 40 00 	ld  [ %i5 ], %g2                               
       (*tty->device.lastClose)(tty->major, tty->minor, arg);         
 20056d4:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         <== NOT EXECUTED
 20056d8:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        <== NOT EXECUTED
 20056dc:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 20056e0:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
    if (tty->forw == NULL) {                                          
 20056e4:	c4 07 40 00 	ld  [ %i5 ], %g2                               <== NOT EXECUTED
 20056e8:	80 a0 a0 00 	cmp  %g2, 0                                    
 20056ec:	12 80 00 08 	bne  200570c <rtems_termios_close+0x138>       
 20056f0:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
      rtems_termios_ttyTail = tty->back;                              
 20056f4:	05 00 80 75 	sethi  %hi(0x201d400), %g2                     
      if ( rtems_termios_ttyTail != NULL ) {                          
 20056f8:	80 a0 60 00 	cmp  %g1, 0                                    
 20056fc:	02 80 00 05 	be  2005710 <rtems_termios_close+0x13c>        <== ALWAYS TAKEN
 2005700:	c2 20 a0 84 	st  %g1, [ %g2 + 0x84 ]                        
        rtems_termios_ttyTail->forw = NULL;                           
 2005704:	10 80 00 03 	b  2005710 <rtems_termios_close+0x13c>         <== NOT EXECUTED
 2005708:	c0 20 40 00 	clr  [ %g1 ]                                   <== NOT EXECUTED
      }                                                               
    } else {                                                          
      tty->forw->back = tty->back;                                    
 200570c:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
 2005710:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
 2005714:	80 a0 a0 00 	cmp  %g2, 0                                    
 2005718:	12 80 00 08 	bne  2005738 <rtems_termios_close+0x164>       <== NEVER TAKEN
 200571c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
      rtems_termios_ttyHead = tty->forw;                              
 2005720:	05 00 80 75 	sethi  %hi(0x201d400), %g2                     
      if ( rtems_termios_ttyHead != NULL ) {                          
 2005724:	80 a0 60 00 	cmp  %g1, 0                                    
 2005728:	02 80 00 05 	be  200573c <rtems_termios_close+0x168>        
 200572c:	c2 20 a0 88 	st  %g1, [ %g2 + 0x88 ]                        
        rtems_termios_ttyHead->back = NULL;                           
 2005730:	10 80 00 03 	b  200573c <rtems_termios_close+0x168>         
 2005734:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
      }                                                               
    } else {                                                          
      tty->back->forw = tty->forw;                                    
 2005738:	c2 20 80 00 	st  %g1, [ %g2 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    rtems_semaphore_delete (tty->isem);                               
 200573c:	40 00 07 b3 	call  2007608 <rtems_semaphore_delete>         
 2005740:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
    rtems_semaphore_delete (tty->osem);                               
 2005744:	40 00 07 b1 	call  2007608 <rtems_semaphore_delete>         
 2005748:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                
 200574c:	40 00 07 af 	call  2007608 <rtems_semaphore_delete>         
 2005750:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
    if ((tty->device.pollRead == NULL) ||                             
 2005754:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
 2005758:	80 a0 60 00 	cmp  %g1, 0                                    
 200575c:	02 80 00 06 	be  2005774 <rtems_termios_close+0x1a0>        
 2005760:	01 00 00 00 	nop                                            
 2005764:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2005768:	80 a0 60 02 	cmp  %g1, 2                                    
 200576c:	12 80 00 04 	bne  200577c <rtems_termios_close+0x1a8>       
 2005770:	01 00 00 00 	nop                                            
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))    
      rtems_semaphore_delete (tty->rawInBuf.Semaphore);               
 2005774:	40 00 07 a5 	call  2007608 <rtems_semaphore_delete>         
 2005778:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
    free (tty->rawInBuf.theBuf);                                      
 200577c:	7f ff f7 8d 	call  20035b0 <free>                           
 2005780:	d0 07 60 58 	ld  [ %i5 + 0x58 ], %o0                        
    free (tty->rawOutBuf.theBuf);                                     
 2005784:	7f ff f7 8b 	call  20035b0 <free>                           
 2005788:	d0 07 60 7c 	ld  [ %i5 + 0x7c ], %o0                        
    free (tty->cbuf);                                                 
 200578c:	7f ff f7 89 	call  20035b0 <free>                           
 2005790:	d0 07 60 1c 	ld  [ %i5 + 0x1c ], %o0                        
    free (tty);                                                       
 2005794:	7f ff f7 87 	call  20035b0 <free>                           
 2005798:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
 200579c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20057a0:	d0 00 60 80 	ld  [ %g1 + 0x80 ], %o0	! 201d480 <rtems_termios_ttyMutex>
 20057a4:	40 00 08 11 	call  20077e8 <rtems_semaphore_release>        
 20057a8:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20057ac:	81 c7 e0 08 	ret                                            
 20057b0:	81 e8 00 00 	restore                                        
                                                                      

02006ba4 <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) {
 2006ba4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
 2006ba8:	c2 06 20 90 	ld  [ %i0 + 0x90 ], %g1                        
 * for each transmitted character.                                    
 * It returns number of characters left to transmit                   
 */                                                                   
int                                                                   
rtems_termios_dequeue_characters (void *ttyp, int len)                
{                                                                     
 2006bac:	90 10 00 18 	mov  %i0, %o0                                  
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
 2006bb0:	b2 00 40 19 	add  %g1, %i1, %i1                             
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
 2006bb4:	c2 06 20 b4 	ld  [ %i0 + 0xb4 ], %g1                        
 2006bb8:	80 a0 60 02 	cmp  %g1, 2                                    
 2006bbc:	12 80 00 0a 	bne  2006be4 <rtems_termios_dequeue_characters+0x40>
 2006bc0:	f2 26 20 90 	st  %i1, [ %i0 + 0x90 ]                        
    /*                                                                
     * send wake up to transmitter task                               
     */                                                               
    sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);     
 2006bc4:	d0 06 20 c8 	ld  [ %i0 + 0xc8 ], %o0                        
 2006bc8:	40 00 01 92 	call  2007210 <rtems_event_send>               
 2006bcc:	92 10 20 02 	mov  2, %o1                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
 2006bd0:	80 a2 20 00 	cmp  %o0, 0                                    
 2006bd4:	02 80 00 11 	be  2006c18 <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
 2006bd8:	b0 10 20 00 	clr  %i0                                       
      rtems_fatal_error_occurred (sc);                                
 2006bdc:	40 00 04 97 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 2006be0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  if (tty->t_line == PPPDISC ) {                                      
 2006be4:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
 2006be8:	80 a0 60 05 	cmp  %g1, 5                                    
 2006bec:	12 80 00 09 	bne  2006c10 <rtems_termios_dequeue_characters+0x6c>
 2006bf0:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
 2006bf4:	c2 00 62 78 	ld  [ %g1 + 0x278 ], %g1	! 201d278 <rtems_termios_linesw+0xb4>
 2006bf8:	80 a0 60 00 	cmp  %g1, 0                                    
 2006bfc:	02 80 00 07 	be  2006c18 <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
 2006c00:	b0 10 20 00 	clr  %i0                                       
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
 2006c04:	9f c0 40 00 	call  %g1                                      
 2006c08:	01 00 00 00 	nop                                            
 2006c0c:	30 80 00 03 	b,a   2006c18 <rtems_termios_dequeue_characters+0x74>
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
 2006c10:	7f ff f8 b0 	call  2004ed0 <rtems_termios_refill_transmitter>
 2006c14:	81 e8 00 00 	restore                                        
}                                                                     
 2006c18:	81 c7 e0 08 	ret                                            
 2006c1c:	81 e8 00 00 	restore                                        
                                                                      

0200683c <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) {
 200683c:	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) {             
 2006840:	c4 06 20 cc 	ld  [ %i0 + 0xcc ], %g2                        
 2006844:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 2006848:	85 28 a0 05 	sll  %g2, 5, %g2                               
 200684c:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
 2006850:	84 00 40 02 	add  %g1, %g2, %g2                             
 2006854:	c4 00 a0 10 	ld  [ %g2 + 0x10 ], %g2                        
 *       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)
{                                                                     
 2006858:	ba 10 00 18 	mov  %i0, %i5                                  
  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);                
 200685c:	b8 10 00 01 	mov  %g1, %i4                                  
  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) {             
 2006860:	80 a0 a0 00 	cmp  %g2, 0                                    
 2006864:	12 80 00 10 	bne  20068a4 <rtems_termios_enqueue_raw_characters+0x68>
 2006868:	b4 06 40 1a 	add  %i1, %i2, %i2                             
 * 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)
 200686c:	b6 10 20 00 	clr  %i3                                       
 2006870:	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); 
 2006874:	a2 07 60 30 	add  %i5, 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);              
 2006878:	10 80 00 a5 	b  2006b0c <rtems_termios_enqueue_raw_characters+0x2d0>
 200687c:	a4 07 60 4a 	add  %i5, 0x4a, %l2                            
  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--) {                                                   
      c = *buf++;                                                     
 2006880:	d0 0e 40 00 	ldub  [ %i1 ], %o0                             
      rtems_termios_linesw[tty->t_line].l_rint(c,tty);                
 2006884:	83 28 60 05 	sll  %g1, 5, %g1                               
 2006888:	82 07 00 01 	add  %i4, %g1, %g1                             
 200688c:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
 2006890:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
  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--) {                                                   
      c = *buf++;                                                     
 2006894:	b2 06 60 01 	inc  %i1                                       
      rtems_termios_linesw[tty->t_line].l_rint(c,tty);                
 2006898:	91 3a 20 18 	sra  %o0, 0x18, %o0                            
 200689c:	9f c0 40 00 	call  %g1                                      
 20068a0:	92 10 00 1d 	mov  %i5, %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--) {                                                   
 20068a4:	80 a6 40 1a 	cmp  %i1, %i2                                  
 20068a8:	32 bf ff f6 	bne,a   2006880 <rtems_termios_enqueue_raw_characters+0x44>
 20068ac:	c2 07 60 cc 	ld  [ %i5 + 0xcc ], %g1                        
    }                                                                 
                                                                      
    /*                                                                
     * check to see if rcv wakeup callback was set                    
     */                                                               
    if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 
 20068b0:	c2 07 60 e4 	ld  [ %i5 + 0xe4 ], %g1                        
 20068b4:	80 a0 60 00 	cmp  %g1, 0                                    
 20068b8:	12 80 00 0b 	bne  20068e4 <rtems_termios_enqueue_raw_characters+0xa8><== NEVER TAKEN
 20068bc:	b0 10 20 00 	clr  %i0                                       
 20068c0:	c2 07 60 dc 	ld  [ %i5 + 0xdc ], %g1                        
 20068c4:	80 a0 60 00 	cmp  %g1, 0                                    
 20068c8:	02 80 00 9b 	be  2006b34 <rtems_termios_enqueue_raw_characters+0x2f8>
 20068cc:	01 00 00 00 	nop                                            
      (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);     
 20068d0:	d2 07 60 e0 	ld  [ %i5 + 0xe0 ], %o1                        
 20068d4:	9f c0 40 00 	call  %g1                                      
 20068d8:	90 07 60 30 	add  %i5, 0x30, %o0                            
      tty->tty_rcvwakeup = 1;                                         
 20068dc:	82 10 20 01 	mov  1, %g1                                    
 20068e0:	c2 27 60 e4 	st  %g1, [ %i5 + 0xe4 ]                        
 20068e4:	81 c7 e0 08 	ret                                            
 20068e8:	81 e8 00 00 	restore                                        
                                                                      
  while (len--) {                                                     
    c = *buf++;                                                       
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
 20068ec:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
    c = *buf++;                                                       
 20068f0:	e0 0e 40 00 	ldub  [ %i1 ], %l0                             
    /* FIXME: implement IXANY: any character restarts output */       
    /* if incoming XON/XOFF controls outgoing stream: */              
    if (tty->flow_ctrl & FL_MDXON) {                                  
 20068f4:	80 88 62 00 	btst  0x200, %g1                               
 20068f8:	02 80 00 17 	be  2006954 <rtems_termios_enqueue_raw_characters+0x118>
 20068fc:	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]) {                            
 2006900:	c4 0f 60 4a 	ldub  [ %i5 + 0x4a ], %g2                      
 2006904:	83 2c 20 18 	sll  %l0, 0x18, %g1                            
 2006908:	83 38 60 18 	sra  %g1, 0x18, %g1                            
 200690c:	80 a0 40 02 	cmp  %g1, %g2                                  
 2006910:	c4 0f 60 49 	ldub  [ %i5 + 0x49 ], %g2                      
 2006914:	12 80 00 0a 	bne  200693c <rtems_termios_enqueue_raw_characters+0x100>
 2006918:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
        if (c == tty->termios.c_cc[VSTART]) {                         
 200691c:	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;               
 2006920:	c2 07 60 b8 	ld  [ %i5 + 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]) {                         
 2006924:	32 80 00 03 	bne,a   2006930 <rtems_termios_enqueue_raw_characters+0xf4><== ALWAYS TAKEN
 2006928:	82 10 60 10 	or  %g1, 0x10, %g1                             
 200692c:	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;                               
 2006930:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
 *       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)
{                                                                     
 2006934:	10 80 00 0b 	b  2006960 <rtems_termios_enqueue_raw_characters+0x124>
 2006938:	b6 10 20 01 	mov  1, %i3                                    
          /* stop output                             */               
          tty->flow_ctrl |= FL_ORCVXOF;                               
        }                                                             
        flow_rcv = true;                                              
      }                                                               
      else if (c == tty->termios.c_cc[VSTART]) {                      
 200693c:	80 a0 40 02 	cmp  %g1, %g2                                  
 2006940:	12 80 00 06 	bne  2006958 <rtems_termios_enqueue_raw_characters+0x11c><== ALWAYS TAKEN
 2006944:	80 8e e0 ff 	btst  0xff, %i3                                
        /* VSTART received */                                         
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
 2006948:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 200694c:	10 bf ff f9 	b  2006930 <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
 2006950:	82 08 7f ef 	and  %g1, -17, %g1                             <== NOT EXECUTED
        flow_rcv = true;                                              
      }                                                               
    }                                                                 
    if (flow_rcv) {                                                   
 2006954:	80 8e e0 ff 	btst  0xff, %i3                                
 2006958:	02 80 00 1c 	be  20069c8 <rtems_termios_enqueue_raw_characters+0x18c><== ALWAYS TAKEN
 200695c:	01 00 00 00 	nop                                            
      /* restart output according to FL_ORCVXOF flag */               
      if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {   
 2006960:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2006964:	82 08 60 30 	and  %g1, 0x30, %g1                            
 2006968:	80 a0 60 20 	cmp  %g1, 0x20                                 
 200696c:	12 80 00 69 	bne  2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
 2006970:	80 a6 40 1a 	cmp  %i1, %i2                                  
        /* disable interrupts    */                                   
        rtems_interrupt_disable(level);                               
 2006974:	7f ff ef 14 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2006978:	01 00 00 00 	nop                                            <== NOT EXECUTED
 200697c:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
        tty->flow_ctrl &= ~FL_OSTOP;                                  
 2006980:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2006984:	82 08 7f df 	and  %g1, -33, %g1                             <== NOT EXECUTED
 2006988:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
 200698c:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        <== NOT EXECUTED
 2006990:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2006994:	02 80 00 09 	be  20069b8 <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
 2006998:	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);
 200699c:	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)(                                       
 20069a0:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        <== NOT EXECUTED
 20069a4:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
 20069a8:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
 20069ac:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
 20069b0:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 20069b4:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
            tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
        }                                                             
        /* reenable interrupts */                                     
        rtems_interrupt_enable(level);                                
 20069b8:	7f ff ef 07 	call  20025d4 <sparc_enable_interrupts>        <== NOT EXECUTED
 20069bc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
 20069c0:	10 80 00 54 	b  2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== NOT EXECUTED
 20069c4:	80 a6 40 1a 	cmp  %i1, %i2                                  <== NOT EXECUTED
        }                                                             
        /* reenable interrupts */                                     
        rtems_interrupt_enable(level);                                
      }                                                               
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
 20069c8:	d0 07 60 60 	ld  [ %i5 + 0x60 ], %o0                        
 20069cc:	d2 07 60 64 	ld  [ %i5 + 0x64 ], %o1                        
 20069d0:	40 00 47 72 	call  2018798 <.urem>                          
 20069d4:	90 02 20 01 	inc  %o0                                       
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
 20069d8:	7f ff ee fb 	call  20025c4 <sparc_disable_interrupts>       
 20069dc:	b8 10 00 08 	mov  %o0, %i4                                  
 20069e0:	a6 10 00 08 	mov  %o0, %l3                                  
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
 20069e4:	c2 07 60 5c 	ld  [ %i5 + 0x5c ], %g1                        
 20069e8:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
            % tty->rawInBuf.Size) > tty->highwater) &&                
 20069ec:	d2 07 60 64 	ld  [ %i5 + 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)       
 20069f0:	90 22 00 01 	sub  %o0, %g1, %o0                             
            % tty->rawInBuf.Size) > tty->highwater) &&                
 20069f4:	40 00 47 69 	call  2018798 <.urem>                          
 20069f8:	90 02 00 1c 	add  %o0, %i4, %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)       
 20069fc:	c2 07 60 c0 	ld  [ %i5 + 0xc0 ], %g1                        
 2006a00:	80 a2 00 01 	cmp  %o0, %g1                                  
 2006a04:	08 80 00 2b 	bleu  2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== ALWAYS TAKEN
 2006a08:	01 00 00 00 	nop                                            
            % tty->rawInBuf.Size) > tty->highwater) &&                
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
 2006a0c:	c2 07 60 b8 	ld  [ %i5 + 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) &&                
 2006a10:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
 2006a14:	12 80 00 27 	bne  2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
 2006a18:	01 00 00 00 	nop                                            <== NOT EXECUTED
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
 2006a1c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2006a20:	82 10 60 01 	or  %g1, 1, %g1                                <== NOT EXECUTED
 2006a24:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
 2006a28:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2006a2c:	82 08 64 02 	and  %g1, 0x402, %g1                           <== NOT EXECUTED
 2006a30:	80 a0 64 00 	cmp  %g1, 0x400                                <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
 2006a34:	c2 07 60 b8 	ld  [ %i5 + 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))                
 2006a38:	32 80 00 12 	bne,a   2006a80 <rtems_termios_enqueue_raw_characters+0x244><== NOT EXECUTED
 2006a3c:	82 08 61 04 	and  %g1, 0x104, %g1                           <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
 2006a40:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
 2006a44:	12 80 00 06 	bne  2006a5c <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
 2006a48:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2006a4c:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        <== NOT EXECUTED
 2006a50:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2006a54:	12 80 00 17 	bne  2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
 2006a58:	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;                             
 2006a5c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
 2006a60:	d0 07 60 10 	ld  [ %i5 + 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;                             
 2006a64:	82 10 60 02 	or  %g1, 2, %g1                                <== NOT EXECUTED
 2006a68:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
 2006a6c:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
 2006a70:	92 10 00 12 	mov  %l2, %o1                                  <== NOT EXECUTED
 2006a74:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2006a78:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
 2006a7c:	30 80 00 0d 	b,a   2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
                (void *)&(tty->termios.c_cc[VSTOP]), 1);              
          }                                                           
        } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
 2006a80:	80 a0 61 00 	cmp  %g1, 0x100                                <== NOT EXECUTED
 2006a84:	12 80 00 0b 	bne  2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
 2006a88:	01 00 00 00 	nop                                            <== NOT EXECUTED
          tty->flow_ctrl |= FL_IRTSOFF;                               
 2006a8c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2006a90:	82 10 60 04 	or  %g1, 4, %g1                                <== NOT EXECUTED
 2006a94:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
 2006a98:	c2 07 60 ac 	ld  [ %i5 + 0xac ], %g1                        <== NOT EXECUTED
 2006a9c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2006aa0:	02 80 00 04 	be  2006ab0 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
 2006aa4:	01 00 00 00 	nop                                            <== NOT EXECUTED
            tty->device.stopRemoteTx(tty->minor);                     
 2006aa8:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2006aac:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
 2006ab0:	7f ff ee c9 	call  20025d4 <sparc_enable_interrupts>        
 2006ab4:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
 2006ab8:	c2 07 60 5c 	ld  [ %i5 + 0x5c ], %g1                        
 2006abc:	80 a7 00 01 	cmp  %i4, %g1                                  
 2006ac0:	32 80 00 04 	bne,a   2006ad0 <rtems_termios_enqueue_raw_characters+0x294><== ALWAYS TAKEN
 2006ac4:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        
        dropped++;                                                    
 2006ac8:	10 80 00 11 	b  2006b0c <rtems_termios_enqueue_raw_characters+0x2d0><== NOT EXECUTED
 2006acc:	b0 06 20 01 	inc  %i0                                       <== NOT EXECUTED
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
 2006ad0:	e0 28 40 1c 	stb  %l0, [ %g1 + %i4 ]                        
        tty->rawInBuf.Tail = newTail;                                 
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
 2006ad4:	c2 07 60 e4 	ld  [ %i5 + 0xe4 ], %g1                        
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
        tty->rawInBuf.Tail = newTail;                                 
 2006ad8:	f8 27 60 60 	st  %i4, [ %i5 + 0x60 ]                        
                                                                      
        /*                                                            
         * check to see if rcv wakeup callback was set                
         */                                                           
        if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
 2006adc:	80 a0 60 00 	cmp  %g1, 0                                    
 2006ae0:	12 80 00 0c 	bne  2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== NEVER TAKEN
 2006ae4:	80 a6 40 1a 	cmp  %i1, %i2                                  
 2006ae8:	c2 07 60 dc 	ld  [ %i5 + 0xdc ], %g1                        
 2006aec:	80 a0 60 00 	cmp  %g1, 0                                    
 2006af0:	02 80 00 08 	be  2006b10 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
 2006af4:	80 a6 40 1a 	cmp  %i1, %i2                                  
          (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 
 2006af8:	d2 07 60 e0 	ld  [ %i5 + 0xe0 ], %o1                        <== NOT EXECUTED
 2006afc:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2006b00:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
          tty->tty_rcvwakeup = 1;                                     
 2006b04:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2006b08:	c2 27 60 e4 	st  %g1, [ %i5 + 0xe4 ]                        <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
 2006b0c:	80 a6 40 1a 	cmp  %i1, %i2                                  
 2006b10:	12 bf ff 77 	bne  20068ec <rtems_termios_enqueue_raw_characters+0xb0>
 2006b14:	01 00 00 00 	nop                                            
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
 2006b18:	c2 07 60 78 	ld  [ %i5 + 0x78 ], %g1                        
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
 2006b1c:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
 2006b20:	82 00 40 18 	add  %g1, %i0, %g1                             
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
 2006b24:	40 00 03 31 	call  20077e8 <rtems_semaphore_release>        
 2006b28:	c2 27 60 78 	st  %g1, [ %i5 + 0x78 ]                        
  return dropped;                                                     
 2006b2c:	81 c7 e0 08 	ret                                            
 2006b30:	81 e8 00 00 	restore                                        
}                                                                     
 2006b34:	81 c7 e0 08 	ret                                            
 2006b38:	81 e8 00 00 	restore                                        
                                                                      

020057d4 <rtems_termios_ioctl>: } } rtems_status_code rtems_termios_ioctl (void *arg) {
 20057d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
 20057d8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer;
 20057dc:	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;                   
 20057e0:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
 20057e4:	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);
 20057e8:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  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;                                             
 20057ec:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 20057f0:	92 10 20 00 	clr  %o1                                       
 20057f4:	40 00 07 b4 	call  20076c4 <rtems_semaphore_obtain>         
 20057f8:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL) {                                       
 20057fc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2005800:	12 80 01 1a 	bne  2005c68 <rtems_termios_ioctl+0x494>       <== NEVER TAKEN
 2005804:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
 2005808:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
 200580c:	80 a0 60 05 	cmp  %g1, 5                                    
 2005810:	22 80 00 e4 	be,a   2005ba0 <rtems_termios_ioctl+0x3cc>     
 2005814:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
 2005818:	18 80 00 12 	bgu  2005860 <rtems_termios_ioctl+0x8c>        
 200581c:	05 10 01 19 	sethi  %hi(0x40046400), %g2                    
 2005820:	80 a0 60 02 	cmp  %g1, 2                                    
 2005824:	22 80 00 34 	be,a   20058f4 <rtems_termios_ioctl+0x120>     
 2005828:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
 200582c:	18 80 00 07 	bgu  2005848 <rtems_termios_ioctl+0x74>        
 2005830:	80 a0 60 03 	cmp  %g1, 3                                    
 2005834:	80 a0 60 01 	cmp  %g1, 1                                    
 2005838:	32 80 00 1e 	bne,a   20058b0 <rtems_termios_ioctl+0xdc>     <== NEVER TAKEN
 200583c:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        <== NOT EXECUTED
      sc = RTEMS_INVALID_NUMBER;                                      
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
 2005840:	10 80 00 29 	b  20058e4 <rtems_termios_ioctl+0x110>         
 2005844:	d0 07 20 08 	ld  [ %i4 + 8 ], %o0                           
  args->ioctl_return = 0;                                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
 2005848:	02 80 00 b3 	be  2005b14 <rtems_termios_ioctl+0x340>        
 200584c:	80 a0 60 04 	cmp  %g1, 4                                    
 2005850:	32 80 00 18 	bne,a   20058b0 <rtems_termios_ioctl+0xdc>     <== NEVER TAKEN
 2005854:	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;                                           
 2005858:	10 80 00 d6 	b  2005bb0 <rtems_termios_ioctl+0x3dc>         
 200585c:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
  args->ioctl_return = 0;                                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
 2005860:	84 10 a2 7f 	or  %g2, 0x27f, %g2                            
 2005864:	80 a0 40 02 	cmp  %g1, %g2                                  
 2005868:	02 80 00 f1 	be  2005c2c <rtems_termios_ioctl+0x458>        <== NEVER TAKEN
 200586c:	01 00 00 00 	nop                                            
 2005870:	38 80 00 07 	bgu,a   200588c <rtems_termios_ioctl+0xb8>     
 2005874:	05 10 01 1d 	sethi  %hi(0x40047400), %g2                    
 2005878:	80 a0 60 06 	cmp  %g1, 6                                    
 200587c:	32 80 00 0d 	bne,a   20058b0 <rtems_termios_ioctl+0xdc>     
 2005880:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
  case RTEMS_IO_TCDRAIN:                                              
    drainOutput (tty);                                                
    break;                                                            
                                                                      
  case RTEMS_IO_TCFLUSH:                                              
    switch ((intptr_t) args->buffer) {                                
 2005884:	10 80 00 ab 	b  2005b30 <rtems_termios_ioctl+0x35c>         
 2005888:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
  args->ioctl_return = 0;                                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
 200588c:	84 10 a0 1a 	or  %g2, 0x1a, %g2                             
 2005890:	80 a0 40 02 	cmp  %g1, %g2                                  
 2005894:	02 80 00 e3 	be  2005c20 <rtems_termios_ioctl+0x44c>        
 2005898:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
 200589c:	07 20 01 1d 	sethi  %hi(0x80047400), %g3                    
 20058a0:	86 10 e0 1b 	or  %g3, 0x1b, %g3	! 8004741b <RAM_END+0x7dc4741b>
 20058a4:	80 a0 40 03 	cmp  %g1, %g3                                  
 20058a8:	02 80 00 c6 	be  2005bc0 <rtems_termios_ioctl+0x3ec>        <== ALWAYS TAKEN
 20058ac:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
  default:                                                            
    if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {          
 20058b0:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
 20058b4:	85 28 a0 05 	sll  %g2, 5, %g2                               
 20058b8:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
 20058bc:	82 00 40 02 	add  %g1, %g2, %g1                             
 20058c0:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
 20058c4:	80 a0 60 00 	cmp  %g1, 0                                    
 20058c8:	02 80 00 e6 	be  2005c60 <rtems_termios_ioctl+0x48c>        
 20058cc:	b0 10 20 0a 	mov  0xa, %i0                                  
      sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);       
 20058d0:	90 10 00 1d 	mov  %i5, %o0                                  
 20058d4:	9f c0 40 00 	call  %g1                                      
 20058d8:	92 10 00 1c 	mov  %i4, %o1                                  
    tty->t_sc = NULL; /* ensure that no more valid data */            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
      sc = rtems_termios_linesw[tty->t_line].l_open(tty);             
 20058dc:	10 80 00 e1 	b  2005c60 <rtems_termios_ioctl+0x48c>         
 20058e0:	b0 10 00 08 	mov  %o0, %i0                                  
      sc = RTEMS_INVALID_NUMBER;                                      
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
 20058e4:	92 07 60 30 	add  %i5, 0x30, %o1                            
 20058e8:	40 00 29 b2 	call  200ffb0 <memcpy>                         
 20058ec:	94 10 20 24 	mov  0x24, %o2                                 
    break;                                                            
 20058f0:	30 80 00 dc 	b,a   2005c60 <rtems_termios_ioctl+0x48c>      
                                                                      
  case RTEMS_IO_SET_ATTRIBUTES:                                       
    tty->termios = *(struct termios *)args->buffer;                   
 20058f4:	90 07 60 30 	add  %i5, 0x30, %o0                            
 20058f8:	40 00 29 ae 	call  200ffb0 <memcpy>                         
 20058fc:	94 10 20 24 	mov  0x24, %o2                                 
  /*                                                                  
   * check for flow control options to be switched off                
   */                                                                 
                                                                      
  /* check for outgoing XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXON) &&                                 
 2005900:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2005904:	80 88 62 00 	btst  0x200, %g1                               
 2005908:	02 80 00 20 	be  2005988 <rtems_termios_ioctl+0x1b4>        
 200590c:	01 00 00 00 	nop                                            
      !(tty->termios.c_iflag & IXON)) {                               
 2005910:	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) &&                                 
 2005914:	80 88 64 00 	btst  0x400, %g1                               
 2005918:	12 80 00 1c 	bne  2005988 <rtems_termios_ioctl+0x1b4>       
 200591c:	01 00 00 00 	nop                                            
      !(tty->termios.c_iflag & IXON)) {                               
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);                       
 2005920:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2005924:	82 08 7d ef 	and  %g1, -529, %g1                            
 2005928:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
 200592c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2005930:	80 88 60 20 	btst  0x20, %g1                                
 2005934:	02 80 00 15 	be  2005988 <rtems_termios_ioctl+0x1b4>        <== ALWAYS TAKEN
 2005938:	01 00 00 00 	nop                                            
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
 200593c:	7f ff f3 22 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2005940:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2005944:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
      tty->flow_ctrl &= ~FL_OSTOP;                                    
 2005948:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 200594c:	82 08 7f df 	and  %g1, -33, %g1                             <== NOT EXECUTED
 2005950:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
 2005954:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        <== NOT EXECUTED
 2005958:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 200595c:	02 80 00 09 	be  2005980 <rtems_termios_ioctl+0x1ac>        <== NOT EXECUTED
 2005960:	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); 
 2005964:	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)(                                         
 2005968:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        <== NOT EXECUTED
 200596c:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
 2005970:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
 2005974:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
 2005978:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 200597c:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
      }                                                               
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
 2005980:	7f ff f3 15 	call  20025d4 <sparc_enable_interrupts>        <== NOT EXECUTED
 2005984:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /* check for incoming XON/XOFF flow control switched off */         
  if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
 2005988:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 200598c:	80 88 64 00 	btst  0x400, %g1                               
 2005990:	02 80 00 0c 	be  20059c0 <rtems_termios_ioctl+0x1ec>        
 2005994:	03 00 00 04 	sethi  %hi(0x1000), %g1                        
 2005998:	c4 07 60 30 	ld  [ %i5 + 0x30 ], %g2                        
 200599c:	80 88 80 01 	btst  %g2, %g1                                 
 20059a0:	12 80 00 08 	bne  20059c0 <rtems_termios_ioctl+0x1ec>       <== NEVER TAKEN
 20059a4:	01 00 00 00 	nop                                            
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXOF);                                    
 20059a8:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 20059ac:	82 08 7b ff 	and  %g1, -1025, %g1                           
 20059b0:	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);                                  
 20059b4:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 20059b8:	82 08 7f fd 	and  %g1, -3, %g1                              
 20059bc:	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)) {
 20059c0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 20059c4:	80 88 61 00 	btst  0x100, %g1                               
 20059c8:	02 80 00 16 	be  2005a20 <rtems_termios_ioctl+0x24c>        <== ALWAYS TAKEN
 20059cc:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
 20059d0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 20059d4:	06 80 00 14 	bl  2005a24 <rtems_termios_ioctl+0x250>        <== NOT EXECUTED
 20059d8:	01 00 00 00 	nop                                            <== NOT EXECUTED
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
 20059dc:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 20059e0:	82 08 7e ff 	and  %g1, -257, %g1                            <== NOT EXECUTED
 20059e4:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
                                                                      
    /* restart remote Tx, if it was stopped */                        
    if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
 20059e8:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 20059ec:	80 88 60 04 	btst  4, %g1                                   <== NOT EXECUTED
 20059f0:	02 80 00 08 	be  2005a10 <rtems_termios_ioctl+0x23c>        <== NOT EXECUTED
 20059f4:	01 00 00 00 	nop                                            <== NOT EXECUTED
 20059f8:	c2 07 60 b0 	ld  [ %i5 + 0xb0 ], %g1                        <== NOT EXECUTED
 20059fc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2005a00:	02 80 00 04 	be  2005a10 <rtems_termios_ioctl+0x23c>        <== NOT EXECUTED
 2005a04:	01 00 00 00 	nop                                            <== NOT EXECUTED
      tty->device.startRemoteTx(tty->minor);                          
 2005a08:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2005a0c:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
    }                                                                 
    tty->flow_ctrl &= ~(FL_IRTSOFF);                                  
 2005a10:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2005a14:	82 08 7f fb 	and  %g1, -5, %g1                              <== NOT EXECUTED
 2005a18:	c2 27 60 b8 	st  %g1, [ %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) {                               
 2005a1c:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        <== NOT EXECUTED
 2005a20:	80 a0 60 00 	cmp  %g1, 0                                    
 2005a24:	36 80 00 06 	bge,a   2005a3c <rtems_termios_ioctl+0x268>    <== ALWAYS TAKEN
 2005a28:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
    tty->flow_ctrl |= FL_MDRTS;                                       
 2005a2c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2005a30:	82 10 61 00 	or  %g1, 0x100, %g1                            <== NOT EXECUTED
 2005a34:	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) {                                 
 2005a38:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
 2005a3c:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
 2005a40:	80 88 40 02 	btst  %g1, %g2                                 
 2005a44:	02 80 00 06 	be  2005a5c <rtems_termios_ioctl+0x288>        
 2005a48:	80 88 64 00 	btst  0x400, %g1                               
    tty->flow_ctrl |= FL_MDXOF;                                       
 2005a4c:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        
 2005a50:	84 10 a4 00 	or  %g2, 0x400, %g2                            
 2005a54:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
 2005a58:	80 88 64 00 	btst  0x400, %g1                               
 2005a5c:	22 80 00 06 	be,a   2005a74 <rtems_termios_ioctl+0x2a0>     
 2005a60:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
    tty->flow_ctrl |= FL_MDXON;                                       
 2005a64:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2005a68:	82 10 62 00 	or  %g1, 0x200, %g1                            
 2005a6c:	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) {                              
 2005a70:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
 2005a74:	80 88 60 02 	btst  2, %g1                                   
 2005a78:	02 80 00 04 	be  2005a88 <rtems_termios_ioctl+0x2b4>        
 2005a7c:	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;                 
 2005a80:	10 80 00 19 	b  2005ae4 <rtems_termios_ioctl+0x310>         
 2005a84:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
      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;          
 2005a88:	40 00 05 55 	call  2006fdc <rtems_clock_get_ticks_per_second>
 2005a8c:	f8 0f 60 46 	ldub  [ %i5 + 0x46 ], %i4                      
    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] *                    
 2005a90:	40 00 4a 5c 	call  2018400 <.umul>                          
 2005a94:	92 10 00 1c 	mov  %i4, %o1                                  
                    rtems_clock_get_ticks_per_second() / 10;          
 2005a98:	40 00 4a 94 	call  20184e8 <.udiv>                          
 2005a9c:	92 10 20 0a 	mov  0xa, %o1                                  
      if (tty->termios.c_cc[VTIME]) {                                 
 2005aa0:	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] *                    
 2005aa4:	d0 27 60 54 	st  %o0, [ %i5 + 0x54 ]                        
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
 2005aa8:	80 a0 60 00 	cmp  %g1, 0                                    
 2005aac:	02 80 00 0a 	be  2005ad4 <rtems_termios_ioctl+0x300>        
 2005ab0:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
 2005ab4:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
        if (tty->termios.c_cc[VMIN])                                  
 2005ab8:	80 88 60 ff 	btst  0xff, %g1                                
 2005abc:	02 80 00 04 	be  2005acc <rtems_termios_ioctl+0x2f8>        
 2005ac0:	d0 27 60 70 	st  %o0, [ %i5 + 0x70 ]                        
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
      } else {                                                        
        if (tty->termios.c_cc[VMIN]) {                                
          tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                 
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
 2005ac4:	10 80 00 0c 	b  2005af4 <rtems_termios_ioctl+0x320>         
 2005ac8:	c0 27 60 74 	clr  [ %i5 + 0x74 ]                            
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
        if (tty->termios.c_cc[VMIN])                                  
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
 2005acc:	10 80 00 0a 	b  2005af4 <rtems_termios_ioctl+0x320>         
 2005ad0:	d0 27 60 74 	st  %o0, [ %i5 + 0x74 ]                        
      } else {                                                        
        if (tty->termios.c_cc[VMIN]) {                                
 2005ad4:	80 88 60 ff 	btst  0xff, %g1                                
 2005ad8:	02 80 00 06 	be  2005af0 <rtems_termios_ioctl+0x31c>        <== ALWAYS TAKEN
 2005adc:	82 10 20 01 	mov  1, %g1                                    
          tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                 
 2005ae0:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            <== NOT EXECUTED
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
 2005ae4:	c0 27 60 70 	clr  [ %i5 + 0x70 ]                            
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
 2005ae8:	10 80 00 03 	b  2005af4 <rtems_termios_ioctl+0x320>         
 2005aec:	c0 27 60 74 	clr  [ %i5 + 0x74 ]                            
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
 2005af0:	c2 27 60 6c 	st  %g1, [ %i5 + 0x6c ]                        
        }                                                             
      }                                                               
    }                                                                 
    if (tty->device.setAttributes)                                    
 2005af4:	c2 07 60 a8 	ld  [ %i5 + 0xa8 ], %g1                        
 2005af8:	80 a0 60 00 	cmp  %g1, 0                                    
 2005afc:	02 80 00 59 	be  2005c60 <rtems_termios_ioctl+0x48c>        
 2005b00:	01 00 00 00 	nop                                            
      (*tty->device.setAttributes)(tty->minor, &tty->termios);        
 2005b04:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
 2005b08:	9f c0 40 00 	call  %g1                                      
 2005b0c:	92 07 60 30 	add  %i5, 0x30, %o1                            
 2005b10:	30 80 00 54 	b,a   2005c60 <rtems_termios_ioctl+0x48c>      
drainOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
  rtems_status_code sc;                                               
                                                                      
  if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {           
 2005b14:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2005b18:	80 a0 60 00 	cmp  %g1, 0                                    
 2005b1c:	02 80 00 51 	be  2005c60 <rtems_termios_ioctl+0x48c>        <== ALWAYS TAKEN
 2005b20:	01 00 00 00 	nop                                            
 2005b24:	7f ff fd 80 	call  2005124 <drainOutput.part.0>             <== NOT EXECUTED
 2005b28:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
 2005b2c:	30 80 00 4d 	b,a   2005c60 <rtems_termios_ioctl+0x48c>      <== NOT EXECUTED
  case RTEMS_IO_TCDRAIN:                                              
    drainOutput (tty);                                                
    break;                                                            
                                                                      
  case RTEMS_IO_TCFLUSH:                                              
    switch ((intptr_t) args->buffer) {                                
 2005b30:	80 a0 60 01 	cmp  %g1, 1                                    
 2005b34:	02 80 00 07 	be  2005b50 <rtems_termios_ioctl+0x37c>        
 2005b38:	80 a0 60 02 	cmp  %g1, 2                                    
 2005b3c:	02 80 00 0b 	be  2005b68 <rtems_termios_ioctl+0x394>        
 2005b40:	80 a0 60 00 	cmp  %g1, 0                                    
 2005b44:	32 80 00 47 	bne,a   2005c60 <rtems_termios_ioctl+0x48c>    
 2005b48:	b0 10 20 03 	mov  3, %i0                                    
 2005b4c:	30 80 00 0e 	b,a   2005b84 <rtems_termios_ioctl+0x3b0>      
static void                                                           
flushOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
 2005b50:	7f ff f2 9d 	call  20025c4 <sparc_disable_interrupts>       
 2005b54:	01 00 00 00 	nop                                            
  tty->rawOutBuf.Tail = 0;                                            
 2005b58:	c0 27 60 84 	clr  [ %i5 + 0x84 ]                            
  tty->rawOutBuf.Head = 0;                                            
 2005b5c:	c0 27 60 80 	clr  [ %i5 + 0x80 ]                            
  tty->rawOutBufState = rob_idle;                                     
 2005b60:	10 80 00 0d 	b  2005b94 <rtems_termios_ioctl+0x3c0>         
 2005b64:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
static void                                                           
flushOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
 2005b68:	7f ff f2 97 	call  20025c4 <sparc_disable_interrupts>       
 2005b6c:	01 00 00 00 	nop                                            
  tty->rawOutBuf.Tail = 0;                                            
 2005b70:	c0 27 60 84 	clr  [ %i5 + 0x84 ]                            
  tty->rawOutBuf.Head = 0;                                            
 2005b74:	c0 27 60 80 	clr  [ %i5 + 0x80 ]                            
  tty->rawOutBufState = rob_idle;                                     
 2005b78:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
  rtems_interrupt_enable (level);                                     
 2005b7c:	7f ff f2 96 	call  20025d4 <sparc_enable_interrupts>        
 2005b80:	01 00 00 00 	nop                                            
static void                                                           
flushInput (struct rtems_termios_tty *tty)                            
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
 2005b84:	7f ff f2 90 	call  20025c4 <sparc_disable_interrupts>       
 2005b88:	01 00 00 00 	nop                                            
  tty->rawInBuf.Tail = 0;                                             
 2005b8c:	c0 27 60 60 	clr  [ %i5 + 0x60 ]                            
  tty->rawInBuf.Head = 0;                                             
 2005b90:	c0 27 60 5c 	clr  [ %i5 + 0x5c ]                            
  rtems_interrupt_enable (level);                                     
 2005b94:	7f ff f2 90 	call  20025d4 <sparc_enable_interrupts>        
 2005b98:	01 00 00 00 	nop                                            
 2005b9c:	30 80 00 31 	b,a   2005c60 <rtems_termios_ioctl+0x48c>      
        break;                                                        
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_SNDWAKEUP:                                            
    tty->tty_snd = *wakeup;                                           
 2005ba0:	c2 27 60 d4 	st  %g1, [ %i5 + 0xd4 ]                        
 2005ba4:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
    break;                                                            
 2005ba8:	10 80 00 2e 	b  2005c60 <rtems_termios_ioctl+0x48c>         
 2005bac:	c2 27 60 d8 	st  %g1, [ %i5 + 0xd8 ]                        
                                                                      
  case RTEMS_IO_RCVWAKEUP:                                            
    tty->tty_rcv = *wakeup;                                           
 2005bb0:	c2 27 60 dc 	st  %g1, [ %i5 + 0xdc ]                        
 2005bb4:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
    break;                                                            
 2005bb8:	10 80 00 2a 	b  2005c60 <rtems_termios_ioctl+0x48c>         
 2005bbc:	c2 27 60 e0 	st  %g1, [ %i5 + 0xe0 ]                        
#if 1 /* FIXME */                                                     
  case TIOCSETD:                                                      
    /*                                                                
     * close old line discipline                                      
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
 2005bc0:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
 2005bc4:	85 28 a0 05 	sll  %g2, 5, %g2                               
 2005bc8:	84 00 40 02 	add  %g1, %g2, %g2                             
 2005bcc:	c2 00 a0 04 	ld  [ %g2 + 4 ], %g1                           
 2005bd0:	80 a0 60 00 	cmp  %g1, 0                                    
 2005bd4:	22 80 00 06 	be,a   2005bec <rtems_termios_ioctl+0x418>     
 2005bd8:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
 2005bdc:	9f c0 40 00 	call  %g1                                      
 2005be0:	90 10 00 1d 	mov  %i5, %o0                                  
 2005be4:	b0 10 00 08 	mov  %o0, %i0                                  
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
 2005be8:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
    tty->t_sc = NULL; /* ensure that no more valid data */            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
 2005bec:	05 00 80 74 	sethi  %hi(0x201d000), %g2                     
     * close old line discipline                                      
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
 2005bf0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    tty->t_sc = NULL; /* ensure that no more valid data */            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
 2005bf4:	84 10 a1 c4 	or  %g2, 0x1c4, %g2                            
     * close old line discipline                                      
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
 2005bf8:	c2 27 60 cc 	st  %g1, [ %i5 + 0xcc ]                        
    tty->t_sc = NULL; /* ensure that no more valid data */            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
 2005bfc:	83 28 60 05 	sll  %g1, 5, %g1                               
 2005c00:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
 2005c04:	80 a0 60 00 	cmp  %g1, 0                                    
 2005c08:	02 80 00 16 	be  2005c60 <rtems_termios_ioctl+0x48c>        
 2005c0c:	c0 27 60 d0 	clr  [ %i5 + 0xd0 ]                            
      sc = rtems_termios_linesw[tty->t_line].l_open(tty);             
 2005c10:	9f c0 40 00 	call  %g1                                      
 2005c14:	90 10 00 1d 	mov  %i5, %o0                                  
 2005c18:	10 80 00 12 	b  2005c60 <rtems_termios_ioctl+0x48c>         
 2005c1c:	b0 10 00 08 	mov  %o0, %i0                                  
    }                                                                 
    break;                                                            
  case TIOCGETD:                                                      
    *(int*)(args->buffer)=tty->t_line;                                
 2005c20:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
    break;                                                            
 2005c24:	10 80 00 0f 	b  2005c60 <rtems_termios_ioctl+0x48c>         
 2005c28:	c4 20 40 00 	st  %g2, [ %g1 ]                               
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
 2005c2c:	c4 07 60 60 	ld  [ %i5 + 0x60 ], %g2                        <== NOT EXECUTED
 2005c30:	c2 07 60 5c 	ld  [ %i5 + 0x5c ], %g1                        <== NOT EXECUTED
      if ( rawnc < 0 )                                                
 2005c34:	82 a0 80 01 	subcc  %g2, %g1, %g1                           <== NOT EXECUTED
 2005c38:	3c 80 00 05 	bpos,a   2005c4c <rtems_termios_ioctl+0x478>   <== NOT EXECUTED
 2005c3c:	c8 07 60 20 	ld  [ %i5 + 0x20 ], %g4                        <== NOT EXECUTED
        rawnc += tty->rawInBuf.Size;                                  
 2005c40:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        <== NOT EXECUTED
 2005c44:	82 00 40 02 	add  %g1, %g2, %g1                             <== NOT EXECUTED
      /* Half guess that this is the right operation */               
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
 2005c48:	c8 07 60 20 	ld  [ %i5 + 0x20 ], %g4                        <== NOT EXECUTED
 2005c4c:	c6 07 60 24 	ld  [ %i5 + 0x24 ], %g3                        <== NOT EXECUTED
 2005c50:	c4 07 20 08 	ld  [ %i4 + 8 ], %g2                           <== NOT EXECUTED
 2005c54:	86 21 00 03 	sub  %g4, %g3, %g3                             <== NOT EXECUTED
 2005c58:	82 00 c0 01 	add  %g3, %g1, %g1                             <== NOT EXECUTED
 2005c5c:	c2 20 80 00 	st  %g1, [ %g2 ]                               <== NOT EXECUTED
    }                                                                 
    break;                                                            
  }                                                                   
                                                                      
  rtems_semaphore_release (tty->osem);                                
 2005c60:	40 00 06 e2 	call  20077e8 <rtems_semaphore_release>        
 2005c64:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  return sc;                                                          
}                                                                     
 2005c68:	81 c7 e0 08 	ret                                            
 2005c6c:	81 e8 00 00 	restore                                        
                                                                      

02005188 <rtems_termios_open>: rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) {
 2005188:	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(                                        
 200518c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2005190:	d0 00 60 80 	ld  [ %g1 + 0x80 ], %o0	! 201d480 <rtems_termios_ttyMutex>
 2005194:	92 10 20 00 	clr  %o1                                       
 2005198:	40 00 09 4b 	call  20076c4 <rtems_semaphore_obtain>         
 200519c:	94 10 20 00 	clr  %o2                                       
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
 20051a0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
 20051a4:	12 80 01 09 	bne  20055c8 <rtems_termios_open+0x440>        <== NEVER TAKEN
 20051a8:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
    return sc;                                                        
                                                                      
  for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 
 20051ac:	e0 00 60 88 	ld  [ %g1 + 0x88 ], %l0	! 201d488 <rtems_termios_ttyHead>
 20051b0:	10 80 00 0a 	b  20051d8 <rtems_termios_open+0x50>           
 20051b4:	ba 10 00 10 	mov  %l0, %i5                                  
    if ((tty->major == major) && (tty->minor == minor))               
 20051b8:	80 a0 40 18 	cmp  %g1, %i0                                  
 20051bc:	32 80 00 07 	bne,a   20051d8 <rtems_termios_open+0x50>      
 20051c0:	fa 07 40 00 	ld  [ %i5 ], %i5                               
 20051c4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 20051c8:	80 a0 40 19 	cmp  %g1, %i1                                  
 20051cc:	22 80 00 d0 	be,a   200550c <rtems_termios_open+0x384>      <== ALWAYS TAKEN
 20051d0:	c2 06 80 00 	ld  [ %i2 ], %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) { 
 20051d4:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
 20051d8:	80 a7 60 00 	cmp  %i5, 0                                    
 20051dc:	32 bf ff f7 	bne,a   20051b8 <rtems_termios_open+0x30>      
 20051e0:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    static char c = 'a';                                              
                                                                      
    /*                                                                
     * Create a new device                                            
     */                                                               
    tty = calloc (1, sizeof (struct rtems_termios_tty));              
 20051e4:	10 80 00 f2 	b  20055ac <rtems_termios_open+0x424>          
 20051e8:	90 10 20 01 	mov  1, %o0                                    
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw input buffer                                      
     */                                                               
    tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                       
 20051ec:	c2 00 62 d8 	ld  [ %g1 + 0x2d8 ], %g1                       
 20051f0:	c2 27 60 64 	st  %g1, [ %i5 + 0x64 ]                        
    tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);               
 20051f4:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
 20051f8:	7f ff f9 c2 	call  2003900 <malloc>                         
 20051fc:	01 00 00 00 	nop                                            
 2005200:	d0 27 60 58 	st  %o0, [ %i5 + 0x58 ]                        
    if (tty->rawInBuf.theBuf == NULL) {                               
 2005204:	80 a2 20 00 	cmp  %o0, 0                                    
 2005208:	02 80 00 16 	be  2005260 <rtems_termios_open+0xd8>          
 200520c:	a2 10 00 08 	mov  %o0, %l1                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw output buffer                                     
     */                                                               
    tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                     
 2005210:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2005214:	c2 00 62 dc 	ld  [ %g1 + 0x2dc ], %g1	! 201cadc <rtems_termios_raw_output_size>
 2005218:	c2 27 60 88 	st  %g1, [ %i5 + 0x88 ]                        
    tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);             
 200521c:	d0 07 60 88 	ld  [ %i5 + 0x88 ], %o0                        
 2005220:	7f ff f9 b8 	call  2003900 <malloc>                         
 2005224:	01 00 00 00 	nop                                            
 2005228:	d0 27 60 7c 	st  %o0, [ %i5 + 0x7c ]                        
    if (tty->rawOutBuf.theBuf == NULL) {                              
 200522c:	80 a2 20 00 	cmp  %o0, 0                                    
 2005230:	02 80 00 0a 	be  2005258 <rtems_termios_open+0xd0>          
 2005234:	a4 10 00 08 	mov  %o0, %l2                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
 2005238:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 200523c:	7f ff f9 b1 	call  2003900 <malloc>                         
 2005240:	d0 00 62 e0 	ld  [ %g1 + 0x2e0 ], %o0	! 201cae0 <rtems_termios_cbufsize>
    if (tty->cbuf == NULL) {                                          
 2005244:	80 a2 20 00 	cmp  %o0, 0                                    
 2005248:	12 80 00 0e 	bne  2005280 <rtems_termios_open+0xf8>         
 200524c:	d0 27 60 1c 	st  %o0, [ %i5 + 0x1c ]                        
            free((void *)(tty->rawOutBuf.theBuf));                    
 2005250:	7f ff f8 d8 	call  20035b0 <free>                           
 2005254:	90 10 00 12 	mov  %l2, %o0                                  
            free((void *)(tty->rawInBuf.theBuf));                     
 2005258:	7f ff f8 d6 	call  20035b0 <free>                           
 200525c:	90 10 00 11 	mov  %l1, %o0                                  
            free(tty);                                                
 2005260:	7f ff f8 d4 	call  20035b0 <free>                           
 2005264:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_semaphore_release (rtems_termios_ttyMutex);               
 2005268:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200526c:	d0 00 60 80 	ld  [ %g1 + 0x80 ], %o0	! 201d480 <rtems_termios_ttyMutex>
 2005270:	40 00 09 5e 	call  20077e8 <rtems_semaphore_release>        
 2005274:	b8 10 20 1a 	mov  0x1a, %i4                                 
      return RTEMS_NO_MEMORY;                                         
 2005278:	81 c7 e0 08 	ret                                            
 200527c:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
    }                                                                 
    /*                                                                
     * Initialize wakeup callbacks                                    
     */                                                               
    tty->tty_snd.sw_pfn = NULL;                                       
 2005280:	c0 27 60 d4 	clr  [ %i5 + 0xd4 ]                            
    tty->tty_snd.sw_arg = NULL;                                       
 2005284:	c0 27 60 d8 	clr  [ %i5 + 0xd8 ]                            
    tty->tty_rcv.sw_pfn = NULL;                                       
 2005288:	c0 27 60 dc 	clr  [ %i5 + 0xdc ]                            
    tty->tty_rcv.sw_arg = NULL;                                       
 200528c:	c0 27 60 e0 	clr  [ %i5 + 0xe0 ]                            
    tty->tty_rcvwakeup  = 0;                                          
 2005290:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
                                                                      
    /*                                                                
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
 2005294:	e0 27 40 00 	st  %l0, [ %i5 ]                               
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
 2005298:	80 a4 20 00 	cmp  %l0, 0                                    
 200529c:	02 80 00 03 	be  20052a8 <rtems_termios_open+0x120>         
 20052a0:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
      rtems_termios_ttyHead->back = tty;                              
 20052a4:	fa 24 20 04 	st  %i5, [ %l0 + 4 ]                           
    rtems_termios_ttyHead = tty;                                      
 20052a8:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20052ac:	fa 20 60 88 	st  %i5, [ %g1 + 0x88 ]	! 201d488 <rtems_termios_ttyHead>
    if (rtems_termios_ttyTail == NULL)                                
 20052b0:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20052b4:	c4 00 60 84 	ld  [ %g1 + 0x84 ], %g2	! 201d484 <rtems_termios_ttyTail>
 20052b8:	80 a0 a0 00 	cmp  %g2, 0                                    
 20052bc:	22 80 00 02 	be,a   20052c4 <rtems_termios_open+0x13c>      
 20052c0:	fa 20 60 84 	st  %i5, [ %g1 + 0x84 ]                        
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'i', c),                            
 20052c4:	21 00 80 72 	sethi  %hi(0x201c800), %l0                     
 20052c8:	d0 4c 22 e4 	ldsb  [ %l0 + 0x2e4 ], %o0	! 201cae4 <c.6880>  
    tty->major = major;                                               
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
 20052cc:	03 15 14 9a 	sethi  %hi(0x54526800), %g1                    
 20052d0:	82 10 61 00 	or  %g1, 0x100, %g1	! 54526900 <RAM_END+0x52126900>
      rtems_termios_ttyHead->back = tty;                              
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
      rtems_termios_ttyTail = tty;                                    
                                                                      
    tty->minor = minor;                                               
 20052d4:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        
    tty->major = major;                                               
 20052d8:	f0 27 60 0c 	st  %i0, [ %i5 + 0xc ]                         
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
 20052dc:	90 12 00 01 	or  %o0, %g1, %o0                              
 20052e0:	92 10 20 01 	mov  1, %o1                                    
 20052e4:	94 10 20 54 	mov  0x54, %o2                                 
 20052e8:	96 10 20 00 	clr  %o3                                       
 20052ec:	40 00 08 59 	call  2007450 <rtems_semaphore_create>         
 20052f0:	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)                                       
 20052f4:	80 a2 20 00 	cmp  %o0, 0                                    
 20052f8:	22 80 00 03 	be,a   2005304 <rtems_termios_open+0x17c>      
 20052fc:	d0 4c 22 e4 	ldsb  [ %l0 + 0x2e4 ], %o0                     
 2005300:	30 80 00 a4 	b,a   2005590 <rtems_termios_open+0x408>       
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
 2005304:	03 15 14 9b 	sethi  %hi(0x54526c00), %g1                    
 2005308:	82 10 63 00 	or  %g1, 0x300, %g1	! 54526f00 <RAM_END+0x52126f00>
 200530c:	92 10 20 01 	mov  1, %o1                                    
 2005310:	90 12 00 01 	or  %o0, %g1, %o0                              
 2005314:	94 10 20 54 	mov  0x54, %o2                                 
 2005318:	96 10 20 00 	clr  %o3                                       
 200531c:	40 00 08 4d 	call  2007450 <rtems_semaphore_create>         
 2005320:	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)                                       
 2005324:	80 a2 20 00 	cmp  %o0, 0                                    
 2005328:	22 80 00 03 	be,a   2005334 <rtems_termios_open+0x1ac>      
 200532c:	d0 4c 22 e4 	ldsb  [ %l0 + 0x2e4 ], %o0                     
 2005330:	30 80 00 98 	b,a   2005590 <rtems_termios_open+0x408>       
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
 2005334:	03 15 14 9e 	sethi  %hi(0x54527800), %g1                    
 2005338:	92 10 20 00 	clr  %o1                                       
 200533c:	90 12 00 01 	or  %o0, %g1, %o0                              
 2005340:	94 10 20 20 	mov  0x20, %o2                                 
 2005344:	96 10 20 00 	clr  %o3                                       
 2005348:	40 00 08 42 	call  2007450 <rtems_semaphore_create>         
 200534c:	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)                                       
 2005350:	80 a2 20 00 	cmp  %o0, 0                                    
 2005354:	22 80 00 03 	be,a   2005360 <rtems_termios_open+0x1d8>      
 2005358:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
 200535c:	30 80 00 8d 	b,a   2005590 <rtems_termios_open+0x408>       
    tty->rawOutBufState = rob_idle;                                   
                                                                      
    /*                                                                
     * Set callbacks                                                  
     */                                                               
    tty->device = *callbacks;                                         
 2005360:	90 07 60 98 	add  %i5, 0x98, %o0                            
 2005364:	92 10 00 1b 	mov  %i3, %o1                                  
 2005368:	40 00 2b 12 	call  200ffb0 <memcpy>                         
 200536c:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
 2005370:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2005374:	80 a0 60 02 	cmp  %g1, 2                                    
 2005378:	32 80 00 1b 	bne,a   20053e4 <rtems_termios_open+0x25c>     
 200537c:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
      sc = rtems_task_create (                                        
                                   rtems_build_name ('T', 'x', 'T', c),
 2005380:	d0 4c 22 e4 	ldsb  [ %l0 + 0x2e4 ], %o0                     
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_create (                                        
 2005384:	03 15 1e 15 	sethi  %hi(0x54785400), %g1                    
 2005388:	92 10 20 0a 	mov  0xa, %o1                                  
 200538c:	90 12 00 01 	or  %o0, %g1, %o0                              
 2005390:	94 10 24 00 	mov  0x400, %o2                                
 2005394:	96 10 25 00 	mov  0x500, %o3                                
 2005398:	98 10 20 00 	clr  %o4                                       
 200539c:	40 00 09 55 	call  20078f0 <rtems_task_create>              
 20053a0:	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)                                     
 20053a4:	80 a2 20 00 	cmp  %o0, 0                                    
 20053a8:	22 80 00 03 	be,a   20053b4 <rtems_termios_open+0x22c>      <== ALWAYS TAKEN
 20053ac:	d0 4c 22 e4 	ldsb  [ %l0 + 0x2e4 ], %o0                     
 20053b0:	30 80 00 78 	b,a   2005590 <rtems_termios_open+0x408>       <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_task_create (                                        
 20053b4:	03 14 9e 15 	sethi  %hi(0x52785400), %g1                    
 20053b8:	92 10 20 09 	mov  9, %o1                                    
 20053bc:	90 12 00 01 	or  %o0, %g1, %o0                              
 20053c0:	94 10 24 00 	mov  0x400, %o2                                
 20053c4:	96 10 25 00 	mov  0x500, %o3                                
 20053c8:	98 10 20 00 	clr  %o4                                       
 20053cc:	40 00 09 49 	call  20078f0 <rtems_task_create>              
 20053d0:	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)                                     
 20053d4:	80 a2 20 00 	cmp  %o0, 0                                    
 20053d8:	22 80 00 03 	be,a   20053e4 <rtems_termios_open+0x25c>      <== ALWAYS TAKEN
 20053dc:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
 20053e0:	30 80 00 6c 	b,a   2005590 <rtems_termios_open+0x408>       <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
 20053e4:	80 a0 60 00 	cmp  %g1, 0                                    
 20053e8:	02 80 00 07 	be  2005404 <rtems_termios_open+0x27c>         
 20053ec:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 20053f0:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 20053f4:	80 a0 60 02 	cmp  %g1, 2                                    
 20053f8:	12 80 00 0f 	bne  2005434 <rtems_termios_open+0x2ac>        
 20053fc:	03 00 00 09 	sethi  %hi(0x2400), %g1                        
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
        rtems_build_name ('T', 'R', 'r', c),                          
 2005400:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2005404:	d0 48 62 e4 	ldsb  [ %g1 + 0x2e4 ], %o0	! 201cae4 <c.6880>  
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
 2005408:	03 15 14 9c 	sethi  %hi(0x54527000), %g1                    
 200540c:	82 10 62 00 	or  %g1, 0x200, %g1	! 54527200 <RAM_END+0x52127200>
 2005410:	92 10 20 00 	clr  %o1                                       
 2005414:	90 12 00 01 	or  %o0, %g1, %o0                              
 2005418:	94 10 20 24 	mov  0x24, %o2                                 
 200541c:	96 10 20 00 	clr  %o3                                       
 2005420:	40 00 08 0c 	call  2007450 <rtems_semaphore_create>         
 2005424:	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)                                     
 2005428:	80 a2 20 00 	cmp  %o0, 0                                    
 200542c:	12 80 00 59 	bne  2005590 <rtems_termios_open+0x408>        <== NEVER TAKEN
 2005430:	03 00 00 09 	sethi  %hi(0x2400), %g1                        
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
 2005434:	82 10 61 02 	or  %g1, 0x102, %g1	! 2502 <PROM_START+0x2502> 
 2005438:	c2 27 60 30 	st  %g1, [ %i5 + 0x30 ]                        
    tty->termios.c_oflag = OPOST | ONLCR | XTABS;                     
 200543c:	03 00 00 06 	sethi  %hi(0x1800), %g1                        
 2005440:	82 10 60 05 	or  %g1, 5, %g1	! 1805 <PROM_START+0x1805>     
 2005444:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
 2005448:	82 10 28 bd 	mov  0x8bd, %g1                                
 200544c:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
    tty->termios.c_lflag =                                            
 2005450:	03 00 00 20 	sethi  %hi(0x8000), %g1                        
 2005454:	82 10 62 3b 	or  %g1, 0x23b, %g1	! 823b <PROM_START+0x823b> 
 2005458:	c2 27 60 3c 	st  %g1, [ %i5 + 0x3c ]                        
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
 200545c:	82 10 20 03 	mov  3, %g1                                    
 2005460:	c2 2f 60 41 	stb  %g1, [ %i5 + 0x41 ]                       
    tty->termios.c_cc[VQUIT] = '\034';                                
 2005464:	82 10 20 1c 	mov  0x1c, %g1                                 
 2005468:	c2 2f 60 42 	stb  %g1, [ %i5 + 0x42 ]                       
    tty->termios.c_cc[VERASE] = '\177';                               
 200546c:	82 10 20 7f 	mov  0x7f, %g1                                 
 2005470:	c2 2f 60 43 	stb  %g1, [ %i5 + 0x43 ]                       
    tty->termios.c_cc[VKILL] = '\025';                                
 2005474:	82 10 20 15 	mov  0x15, %g1                                 
 2005478:	c2 2f 60 44 	stb  %g1, [ %i5 + 0x44 ]                       
    tty->termios.c_cc[VEOF] = '\004';                                 
 200547c:	82 10 20 04 	mov  4, %g1                                    
 2005480:	c2 2f 60 45 	stb  %g1, [ %i5 + 0x45 ]                       
    tty->termios.c_cc[VEOL] = '\000';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
    tty->termios.c_cc[VSTART] = '\021';                               
 2005484:	82 10 20 11 	mov  0x11, %g1                                 
 2005488:	c2 2f 60 49 	stb  %g1, [ %i5 + 0x49 ]                       
    tty->termios.c_cc[VSTOP] = '\023';                                
 200548c:	82 10 20 13 	mov  0x13, %g1                                 
 2005490:	c2 2f 60 4a 	stb  %g1, [ %i5 + 0x4a ]                       
    tty->termios.c_cc[VSUSP] = '\032';                                
 2005494:	82 10 20 1a 	mov  0x1a, %g1                                 
 2005498:	c2 2f 60 4b 	stb  %g1, [ %i5 + 0x4b ]                       
    tty->termios.c_cc[VREPRINT] = '\022';                             
 200549c:	82 10 20 12 	mov  0x12, %g1                                 
 20054a0:	c2 2f 60 4d 	stb  %g1, [ %i5 + 0x4d ]                       
    tty->termios.c_cc[VDISCARD] = '\017';                             
 20054a4:	82 10 20 0f 	mov  0xf, %g1                                  
 20054a8:	c2 2f 60 4e 	stb  %g1, [ %i5 + 0x4e ]                       
    tty->termios.c_cc[VWERASE] = '\027';                              
 20054ac:	82 10 20 17 	mov  0x17, %g1                                 
 20054b0:	c2 2f 60 4f 	stb  %g1, [ %i5 + 0x4f ]                       
    tty->termios.c_cc[VLNEXT] = '\026';                               
 20054b4:	82 10 20 16 	mov  0x16, %g1                                 
                                                                      
    /* start with no flow control, clear flow control flags */        
    tty->flow_ctrl = 0;                                               
 20054b8:	c0 27 60 b8 	clr  [ %i5 + 0xb8 ]                            
    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';                               
 20054bc:	c2 2f 60 50 	stb  %g1, [ %i5 + 0x50 ]                       
    /* 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;                        
 20054c0:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
    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';                                 
 20054c4:	c0 2f 60 4c 	clrb  [ %i5 + 0x4c ]                           
    /* 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;                        
 20054c8:	83 30 60 01 	srl  %g1, 1, %g1                               
 20054cc:	c2 27 60 bc 	st  %g1, [ %i5 + 0xbc ]                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
 20054d0:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
    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';                                 
    tty->termios.c_cc[VEOL2] = '\000';                                
 20054d4:	c0 2f 60 51 	clrb  [ %i5 + 0x51 ]                           
    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;                        
 20054d8:	85 28 60 01 	sll  %g1, 1, %g2                               
 20054dc:	82 00 80 01 	add  %g2, %g1, %g1                             
 20054e0:	83 30 60 02 	srl  %g1, 2, %g1                               
 20054e4:	c2 27 60 c0 	st  %g1, [ %i5 + 0xc0 ]                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
 20054e8:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 20054ec:	c4 08 62 e4 	ldub  [ %g1 + 0x2e4 ], %g2	! 201cae4 <c.6880>  
 20054f0:	c6 48 62 e4 	ldsb  [ %g1 + 0x2e4 ], %g3                     
 20054f4:	80 a0 e0 7a 	cmp  %g3, 0x7a                                 
 20054f8:	12 80 00 03 	bne  2005504 <rtems_termios_open+0x37c>        
 20054fc:	84 00 a0 01 	inc  %g2                                       
      c = 'a';                                                        
 2005500:	84 10 20 61 	mov  0x61, %g2                                 
 2005504:	c4 28 62 e4 	stb  %g2, [ %g1 + 0x2e4 ]                      
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
 2005508:	c2 06 80 00 	ld  [ %i2 ], %g1                               
 200550c:	fa 20 60 30 	st  %i5, [ %g1 + 0x30 ]                        
  if (!tty->refcount++) {                                             
 2005510:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
 2005514:	84 00 60 01 	add  %g1, 1, %g2                               
 2005518:	80 a0 60 00 	cmp  %g1, 0                                    
 200551c:	12 80 00 1f 	bne  2005598 <rtems_termios_open+0x410>        
 2005520:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
    if (tty->device.firstOpen)                                        
 2005524:	c2 07 60 98 	ld  [ %i5 + 0x98 ], %g1                        
 2005528:	80 a0 60 00 	cmp  %g1, 0                                    
 200552c:	02 80 00 05 	be  2005540 <rtems_termios_open+0x3b8>         
 2005530:	90 10 00 18 	mov  %i0, %o0                                  
      (*tty->device.firstOpen)(major, minor, arg);                    
 2005534:	92 10 00 19 	mov  %i1, %o1                                  
 2005538:	9f c0 40 00 	call  %g1                                      
 200553c:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
 2005540:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2005544:	80 a0 60 02 	cmp  %g1, 2                                    
 2005548:	12 80 00 15 	bne  200559c <rtems_termios_open+0x414>        
 200554c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
      sc = rtems_task_start(                                          
 2005550:	d0 07 60 c4 	ld  [ %i5 + 0xc4 ], %o0                        
 2005554:	13 00 80 1a 	sethi  %hi(0x2006800), %o1                     
 2005558:	94 10 00 1d 	mov  %i5, %o2                                  
 200555c:	40 00 09 8a 	call  2007b84 <rtems_task_start>               
 2005560:	92 12 63 3c 	or  %o1, 0x33c, %o1                            
        tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
 2005564:	80 a2 20 00 	cmp  %o0, 0                                    
 2005568:	22 80 00 03 	be,a   2005574 <rtems_termios_open+0x3ec>      <== ALWAYS TAKEN
 200556c:	d0 07 60 c8 	ld  [ %i5 + 0xc8 ], %o0                        
 2005570:	30 80 00 08 	b,a   2005590 <rtems_termios_open+0x408>       <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
                                                                      
      sc = rtems_task_start(                                          
 2005574:	13 00 80 14 	sethi  %hi(0x2005000), %o1                     
 2005578:	94 10 00 1d 	mov  %i5, %o2                                  
 200557c:	40 00 09 82 	call  2007b84 <rtems_task_start>               
 2005580:	92 12 60 b4 	or  %o1, 0xb4, %o1                             
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
 2005584:	80 a2 20 00 	cmp  %o0, 0                                    
 2005588:	02 80 00 05 	be  200559c <rtems_termios_open+0x414>         <== ALWAYS TAKEN
 200558c:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
        rtems_fatal_error_occurred (sc);                              
 2005590:	40 00 0a 2a 	call  2007e38 <rtems_fatal_error_occurred>     
 2005594:	01 00 00 00 	nop                                            
    }                                                                 
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
 2005598:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 200559c:	40 00 08 93 	call  20077e8 <rtems_semaphore_release>        
 20055a0:	d0 00 60 80 	ld  [ %g1 + 0x80 ], %o0	! 201d480 <rtems_termios_ttyMutex>
  return RTEMS_SUCCESSFUL;                                            
 20055a4:	81 c7 e0 08 	ret                                            
 20055a8:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
    static char c = 'a';                                              
                                                                      
    /*                                                                
     * Create a new device                                            
     */                                                               
    tty = calloc (1, sizeof (struct rtems_termios_tty));              
 20055ac:	7f ff f7 4e 	call  20032e4 <calloc>                         
 20055b0:	92 10 20 e8 	mov  0xe8, %o1                                 
    if (tty == NULL) {                                                
 20055b4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 20055b8:	32 bf ff 0d 	bne,a   20051ec <rtems_termios_open+0x64>      
 20055bc:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
    tty->cbuf  = malloc (CBUFSIZE);                                   
    if (tty->cbuf == NULL) {                                          
            free((void *)(tty->rawOutBuf.theBuf));                    
            free((void *)(tty->rawInBuf.theBuf));                     
            free(tty);                                                
      rtems_semaphore_release (rtems_termios_ttyMutex);               
 20055c0:	10 bf ff 2b 	b  200526c <rtems_termios_open+0xe4>           
 20055c4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
        rtems_fatal_error_occurred (sc);                              
    }                                                                 
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
 20055c8:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
 20055cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20055d0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02005c70 <rtems_termios_puts>: * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, size_t len, struct rtems_termios_tty *tty) {
 2005c70:	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) {           
 2005c74:	c2 06 a0 b4 	ld  [ %i2 + 0xb4 ], %g1                        
 2005c78:	80 a0 60 00 	cmp  %g1, 0                                    
 2005c7c:	12 80 00 08 	bne  2005c9c <rtems_termios_puts+0x2c>         
 2005c80:	92 10 00 18 	mov  %i0, %o1                                  
    (*tty->device.write)(tty->minor, buf, len);                       
 2005c84:	c2 06 a0 a4 	ld  [ %i2 + 0xa4 ], %g1                        
 2005c88:	d0 06 a0 10 	ld  [ %i2 + 0x10 ], %o0                        
 2005c8c:	9f c0 40 00 	call  %g1                                      
 2005c90:	94 10 00 19 	mov  %i1, %o2                                  
    return;                                                           
 2005c94:	81 c7 e0 08 	ret                                            
 2005c98:	81 e8 00 00 	restore                                        
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
 2005c9c:	fa 06 a0 80 	ld  [ %i2 + 0x80 ], %i5                        
                                                                      
/*                                                                    
 * Send characters to device-specific code                            
 */                                                                   
void                                                                  
rtems_termios_puts (                                                  
 2005ca0:	b2 06 00 19 	add  %i0, %i1, %i1                             
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
    rtems_interrupt_disable (level);                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
      tty->rawOutBufState = rob_wait;                                 
 2005ca4:	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) {                                                       
 2005ca8:	10 80 00 36 	b  2005d80 <rtems_termios_puts+0x110>          
 2005cac:	a0 10 20 01 	mov  1, %l0                                    
     *  len -= ncopy                                                  
     *                                                                
     * To minimize latency, the memcpy should be done                 
     * with interrupts enabled.                                       
     */                                                               
    newHead = (newHead + 1) % tty->rawOutBuf.Size;                    
 2005cb0:	d2 06 a0 88 	ld  [ %i2 + 0x88 ], %o1                        
 2005cb4:	40 00 4a b9 	call  2018798 <.urem>                          
 2005cb8:	90 07 60 01 	add  %i5, 1, %o0                               
 2005cbc:	10 80 00 0d 	b  2005cf0 <rtems_termios_puts+0x80>           
 2005cc0:	ba 10 00 08 	mov  %o0, %i5                                  
    rtems_interrupt_disable (level);                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
      tty->rawOutBufState = rob_wait;                                 
      rtems_interrupt_enable (level);                                 
 2005cc4:	7f ff f2 44 	call  20025d4 <sparc_enable_interrupts>        
 2005cc8:	90 10 00 1c 	mov  %i4, %o0                                  
      sc = rtems_semaphore_obtain(                                    
 2005ccc:	d0 06 a0 8c 	ld  [ %i2 + 0x8c ], %o0                        
 2005cd0:	92 10 20 00 	clr  %o1                                       
 2005cd4:	40 00 06 7c 	call  20076c4 <rtems_semaphore_obtain>         
 2005cd8:	94 10 20 00 	clr  %o2                                       
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
 2005cdc:	80 a2 20 00 	cmp  %o0, 0                                    
 2005ce0:	02 80 00 04 	be  2005cf0 <rtems_termios_puts+0x80>          <== ALWAYS TAKEN
 2005ce4:	01 00 00 00 	nop                                            
        rtems_fatal_error_occurred (sc);                              
 2005ce8:	40 00 08 54 	call  2007e38 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 2005cec:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_interrupt_disable (level);                                
 2005cf0:	7f ff f2 35 	call  20025c4 <sparc_disable_interrupts>       
 2005cf4:	01 00 00 00 	nop                                            
 2005cf8:	b8 10 00 08 	mov  %o0, %i4                                  
     * 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) {                          
 2005cfc:	c2 06 a0 84 	ld  [ %i2 + 0x84 ], %g1                        
 2005d00:	80 a7 40 01 	cmp  %i5, %g1                                  
 2005d04:	22 bf ff f0 	be,a   2005cc4 <rtems_termios_puts+0x54>       
 2005d08:	f6 26 a0 94 	st  %i3, [ %i2 + 0x94 ]                        
        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++;              
 2005d0c:	c2 06 a0 80 	ld  [ %i2 + 0x80 ], %g1                        
 2005d10:	c6 0e 00 00 	ldub  [ %i0 ], %g3                             
 2005d14:	c4 06 a0 7c 	ld  [ %i2 + 0x7c ], %g2                        
 2005d18:	b0 06 20 01 	inc  %i0                                       
 2005d1c:	c6 28 80 01 	stb  %g3, [ %g2 + %g1 ]                        
    tty->rawOutBuf.Head = newHead;                                    
    if (tty->rawOutBufState == rob_idle) {                            
 2005d20:	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;                                    
 2005d24:	fa 26 a0 80 	st  %i5, [ %i2 + 0x80 ]                        
    if (tty->rawOutBufState == rob_idle) {                            
 2005d28:	80 a0 60 00 	cmp  %g1, 0                                    
 2005d2c:	12 80 00 13 	bne  2005d78 <rtems_termios_puts+0x108>        
 2005d30:	01 00 00 00 	nop                                            
      /* check, whether XOFF has been received */                     
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
 2005d34:	c2 06 a0 b8 	ld  [ %i2 + 0xb8 ], %g1                        
 2005d38:	80 88 60 10 	btst  0x10, %g1                                
 2005d3c:	12 80 00 0b 	bne  2005d68 <rtems_termios_puts+0xf8>         <== NEVER TAKEN
 2005d40:	01 00 00 00 	nop                                            
        (*tty->device.write)(                                         
          tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 
 2005d44:	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)(                                         
 2005d48:	d2 06 a0 7c 	ld  [ %i2 + 0x7c ], %o1                        
 2005d4c:	c2 06 a0 a4 	ld  [ %i2 + 0xa4 ], %g1                        
 2005d50:	d0 06 a0 10 	ld  [ %i2 + 0x10 ], %o0                        
 2005d54:	92 02 40 02 	add  %o1, %g2, %o1                             
 2005d58:	9f c0 40 00 	call  %g1                                      
 2005d5c:	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;                                 
 2005d60:	10 80 00 06 	b  2005d78 <rtems_termios_puts+0x108>          
 2005d64:	e0 26 a0 94 	st  %l0, [ %i2 + 0x94 ]                        
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
        (*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;                                   
 2005d68:	c2 06 a0 b8 	ld  [ %i2 + 0xb8 ], %g1                        <== NOT EXECUTED
 2005d6c:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
 2005d70:	c2 26 a0 b8 	st  %g1, [ %i2 + 0xb8 ]                        <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy;                                 
 2005d74:	e0 26 a0 94 	st  %l0, [ %i2 + 0x94 ]                        <== NOT EXECUTED
    }                                                                 
    rtems_interrupt_enable (level);                                   
 2005d78:	7f ff f2 17 	call  20025d4 <sparc_enable_interrupts>        
 2005d7c:	90 10 00 1c 	mov  %i4, %o0                                  
  if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {           
    (*tty->device.write)(tty->minor, buf, len);                       
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
  while (len) {                                                       
 2005d80:	80 a6 00 19 	cmp  %i0, %i1                                  
 2005d84:	12 bf ff cb 	bne  2005cb0 <rtems_termios_puts+0x40>         
 2005d88:	01 00 00 00 	nop                                            
 2005d8c:	81 c7 e0 08 	ret                                            
 2005d90:	81 e8 00 00 	restore                                        
                                                                      

02006484 <rtems_termios_read>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) {
 2006484:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
 2006488:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  uint32_t   count = args->count;                                     
  char      *buffer = args->buffer;                                   
 200648c:	f4 1e 20 10 	ldd  [ %i0 + 0x10 ], %i2                       
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
 2006490:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_read (void *arg)                                        
{                                                                     
 2006494:	b8 10 00 18 	mov  %i0, %i4                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
  uint32_t   count = args->count;                                     
  char      *buffer = args->buffer;                                   
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 2006498:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
 200649c:	92 10 20 00 	clr  %o1                                       
 20064a0:	40 00 04 89 	call  20076c4 <rtems_semaphore_obtain>         
 20064a4:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 20064a8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20064ac:	12 80 00 dd 	bne  2006820 <rtems_termios_read+0x39c>        <== NEVER TAKEN
 20064b0:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    return sc;                                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_read != NULL) {             
 20064b4:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
 20064b8:	85 28 a0 05 	sll  %g2, 5, %g2                               
 20064bc:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
 20064c0:	82 00 40 02 	add  %g1, %g2, %g1                             
 20064c4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
 20064c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20064cc:	02 80 00 06 	be  20064e4 <rtems_termios_read+0x60>          
 20064d0:	90 10 00 1d 	mov  %i5, %o0                                  
    sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);          
 20064d4:	9f c0 40 00 	call  %g1                                      
 20064d8:	92 10 00 1c 	mov  %i4, %o1                                  
 20064dc:	10 80 00 ce 	b  2006814 <rtems_termios_read+0x390>          
 20064e0:	b0 10 00 08 	mov  %o0, %i0                                  
    tty->tty_rcvwakeup = 0;                                           
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
 20064e4:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
 20064e8:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 20064ec:	80 a0 80 01 	cmp  %g2, %g1                                  
 20064f0:	12 80 00 bf 	bne  20067ec <rtems_termios_read+0x368>        <== NEVER TAKEN
 20064f4:	80 a6 e0 00 	cmp  %i3, 0                                    
    tty->cindex = tty->ccount = 0;                                    
    tty->read_start_column = tty->column;                             
 20064f8:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
    tty->cindex = tty->ccount = 0;                                    
 20064fc:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
    tty->read_start_column = tty->column;                             
 2006500:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
    if (tty->device.pollRead != NULL &&                               
 2006504:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
 2006508:	80 a0 60 00 	cmp  %g1, 0                                    
 200650c:	02 80 00 4c 	be  200663c <rtems_termios_read+0x1b8>         
 2006510:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
 2006514:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
 2006518:	80 a0 60 00 	cmp  %g1, 0                                    
 200651c:	32 80 00 49 	bne,a   2006640 <rtems_termios_read+0x1bc>     
 2006520:	e0 07 60 74 	ld  [ %i5 + 0x74 ], %l0                        
static rtems_status_code                                              
fillBufferPoll (struct rtems_termios_tty *tty)                        
{                                                                     
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
 2006524:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
 2006528:	80 88 60 02 	btst  2, %g1                                   
 200652c:	02 80 00 13 	be  2006578 <rtems_termios_read+0xf4>          
 2006530:	01 00 00 00 	nop                                            
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
 2006534:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
 2006538:	9f c0 40 00 	call  %g1                                      
 200653c:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      if (n < 0) {                                                    
 2006540:	80 a2 20 00 	cmp  %o0, 0                                    
 2006544:	16 80 00 06 	bge  200655c <rtems_termios_read+0xd8>         
 2006548:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
        rtems_task_wake_after (1);                                    
 200654c:	40 00 05 aa 	call  2007bf4 <rtems_task_wake_after>          
 2006550:	90 10 20 01 	mov  1, %o0                                    
{                                                                     
  int n;                                                              
                                                                      
  if (tty->termios.c_lflag & ICANON) {                                
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
 2006554:	10 bf ff f9 	b  2006538 <rtems_termios_read+0xb4>           
 2006558:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
      if (n < 0) {                                                    
        rtems_task_wake_after (1);                                    
      } else {                                                        
        if  (siproc (n, tty))                                         
 200655c:	7f ff ff 88 	call  200637c <siproc>                         
 2006560:	92 10 00 1d 	mov  %i5, %o1                                  
 2006564:	80 a2 20 00 	cmp  %o0, 0                                    
 2006568:	22 bf ff f4 	be,a   2006538 <rtems_termios_read+0xb4>       
 200656c:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
 2006570:	10 80 00 9f 	b  20067ec <rtems_termios_read+0x368>          
 2006574:	80 a6 e0 00 	cmp  %i3, 0                                    
      }                                                               
    }                                                                 
  } else {                                                            
    rtems_interval then, now;                                         
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
 2006578:	40 00 02 a1 	call  2006ffc <rtems_clock_get_ticks_since_boot>
 200657c:	01 00 00 00 	nop                                            
 2006580:	b2 10 00 08 	mov  %o0, %i1                                  
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
 2006584:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
 2006588:	9f c0 40 00 	call  %g1                                      
 200658c:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      if (n < 0) {                                                    
 2006590:	80 a2 20 00 	cmp  %o0, 0                                    
 2006594:	36 80 00 1c 	bge,a   2006604 <rtems_termios_read+0x180>     
 2006598:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
        if (tty->termios.c_cc[VMIN]) {                                
 200659c:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
 20065a0:	80 a0 60 00 	cmp  %g1, 0                                    
 20065a4:	02 80 00 0d 	be  20065d8 <rtems_termios_read+0x154>         
 20065a8:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
          if (tty->termios.c_cc[VTIME] && tty->ccount) {              
 20065ac:	80 88 60 ff 	btst  0xff, %g1                                
 20065b0:	32 80 00 06 	bne,a   20065c8 <rtems_termios_read+0x144>     <== ALWAYS TAKEN
 20065b4:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
          now = rtems_clock_get_ticks_since_boot();                   
          if ((now - then) > tty->vtimeTicks) {                       
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
 20065b8:	40 00 05 8f 	call  2007bf4 <rtems_task_wake_after>          
 20065bc:	90 10 20 01 	mov  1, %o0                                    
  } else {                                                            
    rtems_interval then, now;                                         
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
 20065c0:	10 bf ff f2 	b  2006588 <rtems_termios_read+0x104>          
 20065c4:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
      if (n < 0) {                                                    
        if (tty->termios.c_cc[VMIN]) {                                
          if (tty->termios.c_cc[VTIME] && tty->ccount) {              
 20065c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20065cc:	02 bf ff fb 	be  20065b8 <rtems_termios_read+0x134>         
 20065d0:	01 00 00 00 	nop                                            
 20065d4:	30 80 00 04 	b,a   20065e4 <rtems_termios_read+0x160>       
            if ((now - then) > tty->vtimeTicks) {                     
              break;                                                  
            }                                                         
          }                                                           
        } else {                                                      
          if (!tty->termios.c_cc[VTIME])                              
 20065d8:	80 88 60 ff 	btst  0xff, %g1                                
 20065dc:	02 80 00 84 	be  20067ec <rtems_termios_read+0x368>         <== NEVER TAKEN
 20065e0:	80 a6 e0 00 	cmp  %i3, 0                                    
            break;                                                    
          now = rtems_clock_get_ticks_since_boot();                   
 20065e4:	40 00 02 86 	call  2006ffc <rtems_clock_get_ticks_since_boot>
 20065e8:	01 00 00 00 	nop                                            
          if ((now - then) > tty->vtimeTicks) {                       
 20065ec:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
 20065f0:	90 22 00 19 	sub  %o0, %i1, %o0                             
 20065f4:	80 a2 00 01 	cmp  %o0, %g1                                  
 20065f8:	08 bf ff f0 	bleu  20065b8 <rtems_termios_read+0x134>       
 20065fc:	80 a6 e0 00 	cmp  %i3, 0                                    
 2006600:	30 80 00 7b 	b,a   20067ec <rtems_termios_read+0x368>       
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
      } else {                                                        
        siproc (n, tty);                                              
 2006604:	7f ff ff 5e 	call  200637c <siproc>                         
 2006608:	92 10 00 1d 	mov  %i5, %o1                                  
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
 200660c:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
 2006610:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
 2006614:	80 a0 80 01 	cmp  %g2, %g1                                  
 2006618:	16 80 00 74 	bge  20067e8 <rtems_termios_read+0x364>        
 200661c:	80 a0 60 00 	cmp  %g1, 0                                    
          break;                                                      
        if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])      
 2006620:	22 bf ff da 	be,a   2006588 <rtems_termios_read+0x104>      <== NEVER TAKEN
 2006624:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        <== NOT EXECUTED
 2006628:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
 200662c:	80 a0 60 00 	cmp  %g1, 0                                    
 2006630:	22 bf ff d6 	be,a   2006588 <rtems_termios_read+0x104>      <== NEVER TAKEN
 2006634:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        <== NOT EXECUTED
 2006638:	30 bf ff d0 	b,a   2006578 <rtems_termios_read+0xf4>        
 * Fill the input buffer from the raw input queue                     
 */                                                                   
static rtems_status_code                                              
fillBufferQueue (struct rtems_termios_tty *tty)                       
{                                                                     
  rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;        
 200663c:	e0 07 60 74 	ld  [ %i5 + 0x74 ], %l0                        
  rtems_status_code sc;                                               
  int               wait = 1;                                         
 2006640:	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))) {                
 2006644:	23 00 80 72 	sethi  %hi(0x201c800), %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);     
 2006648:	10 80 00 4b 	b  2006774 <rtems_termios_read+0x2f0>          
 200664c:	a4 07 60 49 	add  %i5, 0x49, %l2                            
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
                       (tty->ccount < (CBUFSIZE-1))) {                
      unsigned char c;                                                
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
 2006650:	d0 07 60 5c 	ld  [ %i5 + 0x5c ], %o0                        
 2006654:	d2 07 60 64 	ld  [ %i5 + 0x64 ], %o1                        
 2006658:	40 00 48 50 	call  2018798 <.urem>                          
 200665c:	90 02 20 01 	inc  %o0                                       
      c = tty->rawInBuf.theBuf[newHead];                              
 2006660:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        
 2006664:	e0 08 40 08 	ldub  [ %g1 + %o0 ], %l0                       
      tty->rawInBuf.Head = newHead;                                   
 2006668:	d0 27 60 5c 	st  %o0, [ %i5 + 0x5c ]                        
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
 200666c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 2006670:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        
          % tty->rawInBuf.Size)                                       
 2006674:	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)             
 2006678:	82 00 80 01 	add  %g2, %g1, %g1                             
          % tty->rawInBuf.Size)                                       
 200667c:	40 00 48 47 	call  2018798 <.urem>                          
 2006680:	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)             
 2006684:	c2 07 60 bc 	ld  [ %i5 + 0xbc ], %g1                        
 2006688:	80 a2 00 01 	cmp  %o0, %g1                                  
 200668c:	3a 80 00 27 	bcc,a   2006728 <rtems_termios_read+0x2a4>     <== NEVER TAKEN
 2006690:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
 2006694:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2006698:	82 08 7f fe 	and  %g1, -2, %g1                              
 200669c:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
 20066a0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 20066a4:	82 08 62 02 	and  %g1, 0x202, %g1                           
 20066a8:	80 a0 62 02 	cmp  %g1, 0x202                                
 20066ac:	12 80 00 11 	bne  20066f0 <rtems_termios_read+0x26c>        <== ALWAYS TAKEN
 20066b0:	01 00 00 00 	nop                                            
             ==                (FL_MDXON | FL_ISNTXOF))               
            && ((tty->rawOutBufState == rob_idle)                     
 20066b4:	c2 07 60 94 	ld  [ %i5 + 0x94 ], %g1                        <== NOT EXECUTED
 20066b8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 20066bc:	22 80 00 07 	be,a   20066d8 <rtems_termios_read+0x254>      <== NOT EXECUTED
 20066c0:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
 20066c4:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 20066c8:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
 20066cc:	02 80 00 09 	be  20066f0 <rtems_termios_read+0x26c>         <== NOT EXECUTED
 20066d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
 20066d4:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
 20066d8:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
 20066dc:	92 10 00 12 	mov  %l2, %o1                                  <== NOT EXECUTED
 20066e0:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 20066e4:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
 20066e8:	10 80 00 10 	b  2006728 <rtems_termios_read+0x2a4>          <== NOT EXECUTED
 20066ec:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %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) {                       
 20066f0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 20066f4:	80 88 61 00 	btst  0x100, %g1                               
 20066f8:	22 80 00 0c 	be,a   2006728 <rtems_termios_read+0x2a4>      <== ALWAYS TAKEN
 20066fc:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
 2006700:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 2006704:	82 08 7f fb 	and  %g1, -5, %g1                              <== NOT EXECUTED
 2006708:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
 200670c:	c2 07 60 b0 	ld  [ %i5 + 0xb0 ], %g1                        <== NOT EXECUTED
 2006710:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
 2006714:	22 80 00 05 	be,a   2006728 <rtems_termios_read+0x2a4>      <== NOT EXECUTED
 2006718:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
            tty->device.startRemoteTx(tty->minor);                    
 200671c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2006720:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
 2006724:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
        if (siproc (c, tty))                                          
 2006728:	92 10 00 1d 	mov  %i5, %o1                                  
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
 200672c:	80 88 60 02 	btst  2, %g1                                   
 2006730:	02 80 00 09 	be  2006754 <rtems_termios_read+0x2d0>         <== NEVER TAKEN
 2006734:	90 0c 20 ff 	and  %l0, 0xff, %o0                            
        if (siproc (c, tty))                                          
 2006738:	7f ff ff 11 	call  200637c <siproc>                         
 200673c:	01 00 00 00 	nop                                            
 2006740:	80 a2 20 00 	cmp  %o0, 0                                    
 2006744:	22 80 00 0c 	be,a   2006774 <rtems_termios_read+0x2f0>      
 2006748:	e0 07 60 70 	ld  [ %i5 + 0x70 ], %l0                        
          wait = 0;                                                   
 200674c:	10 80 00 09 	b  2006770 <rtems_termios_read+0x2ec>          
 2006750:	b2 10 20 00 	clr  %i1                                       
      } else {                                                        
        siproc (c, tty);                                              
 2006754:	7f ff ff 0a 	call  200637c <siproc>                         <== NOT EXECUTED
 2006758:	01 00 00 00 	nop                                            <== NOT EXECUTED
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
 200675c:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      <== NOT EXECUTED
 2006760:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        <== NOT EXECUTED
 2006764:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
 2006768:	36 80 00 02 	bge,a   2006770 <rtems_termios_read+0x2ec>     <== NOT EXECUTED
 200676c:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
          wait = 0;                                                   
      }                                                               
      timeout = tty->rawInBufSemaphoreTimeout;                        
 2006770:	e0 07 60 70 	ld  [ %i5 + 0x70 ], %l0                        
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
 2006774:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
 2006778:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 200677c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2006780:	12 80 00 07 	bne  200679c <rtems_termios_read+0x318>        
 2006784:	c2 04 62 e0 	ld  [ %l1 + 0x2e0 ], %g1                       
    }                                                                 
                                                                      
    /*                                                                
     * Wait for characters                                            
     */                                                               
    if ( wait ) {                                                     
 2006788:	80 a6 60 00 	cmp  %i1, 0                                    
 200678c:	02 80 00 18 	be  20067ec <rtems_termios_read+0x368>         
 2006790:	80 a6 e0 00 	cmp  %i3, 0                                    
      sc = rtems_semaphore_obtain(                                    
 2006794:	10 80 00 08 	b  20067b4 <rtems_termios_read+0x330>          
 2006798:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
 200679c:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
                       (tty->ccount < (CBUFSIZE-1))) {                
 20067a0:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
 20067a4:	80 a0 80 01 	cmp  %g2, %g1                                  
 20067a8:	0a bf ff aa 	bcs  2006650 <rtems_termios_read+0x1cc>        <== ALWAYS TAKEN
 20067ac:	80 a6 60 00 	cmp  %i1, 0                                    
 20067b0:	30 bf ff f7 	b,a   200678c <rtems_termios_read+0x308>       <== NOT EXECUTED
                                                                      
    /*                                                                
     * Wait for characters                                            
     */                                                               
    if ( wait ) {                                                     
      sc = rtems_semaphore_obtain(                                    
 20067b4:	d2 07 60 6c 	ld  [ %i5 + 0x6c ], %o1                        
 20067b8:	40 00 03 c3 	call  20076c4 <rtems_semaphore_obtain>         
 20067bc:	94 10 00 10 	mov  %l0, %o2                                  
        tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
      if (sc != RTEMS_SUCCESSFUL)                                     
 20067c0:	80 a2 20 00 	cmp  %o0, 0                                    
 20067c4:	02 bf ff ec 	be  2006774 <rtems_termios_read+0x2f0>         <== ALWAYS TAKEN
 20067c8:	80 a6 e0 00 	cmp  %i3, 0                                    
 20067cc:	30 80 00 08 	b,a   20067ec <rtems_termios_read+0x368>       <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
 20067d0:	b6 06 ff ff 	add  %i3, -1, %i3                              
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
    *buffer++ = tty->cbuf[tty->cindex++];                             
 20067d4:	c4 08 80 01 	ldub  [ %g2 + %g1 ], %g2                       
 20067d8:	82 00 60 01 	inc  %g1                                       
 20067dc:	c4 2e 80 00 	stb  %g2, [ %i2 ]                              
 20067e0:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
 20067e4:	b4 06 a0 01 	inc  %i2                                       
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
 20067e8:	80 a6 e0 00 	cmp  %i3, 0                                    
 20067ec:	22 80 00 08 	be,a   200680c <rtems_termios_read+0x388>      
 20067f0:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
 20067f4:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
 20067f8:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
 20067fc:	80 a0 40 02 	cmp  %g1, %g2                                  
 2006800:	26 bf ff f4 	bl,a   20067d0 <rtems_termios_read+0x34c>      
 2006804:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
 2006808:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
 200680c:	b6 20 40 1b 	sub  %g1, %i3, %i3                             
 2006810:	f6 27 20 1c 	st  %i3, [ %i4 + 0x1c ]                        
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
 2006814:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
 2006818:	40 00 03 f4 	call  20077e8 <rtems_semaphore_release>        
 200681c:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
  return sc;                                                          
}                                                                     
 2006820:	81 c7 e0 08 	ret                                            
 2006824:	81 e8 00 00 	restore                                        
                                                                      

02004ed0 <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) {
 2004ed0:	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))         
 2004ed4:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
 2004ed8:	82 08 64 03 	and  %g1, 0x403, %g1                           
 2004edc:	80 a0 64 01 	cmp  %g1, 0x401                                
 2004ee0:	12 80 00 0f 	bne  2004f1c <rtems_termios_refill_transmitter+0x4c><== ALWAYS TAKEN
 2004ee4:	ba 10 00 18 	mov  %i0, %i5                                  
      == (FL_MDXOF | FL_IREQXOF)) {                                   
    /* XOFF should be sent now... */                                  
    (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
 2004ee8:	c2 06 20 a4 	ld  [ %i0 + 0xa4 ], %g1                        <== NOT EXECUTED
 2004eec:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
 2004ef0:	92 06 20 4a 	add  %i0, 0x4a, %o1                            <== NOT EXECUTED
 2004ef4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2004ef8:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
 2004efc:	7f ff f5 b2 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2004f00:	01 00 00 00 	nop                                            <== NOT EXECUTED
    tty->t_dqlen--;                                                   
 2004f04:	c2 06 20 90 	ld  [ %i0 + 0x90 ], %g1                        <== NOT EXECUTED
 2004f08:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
 2004f0c:	c2 26 20 90 	st  %g1, [ %i0 + 0x90 ]                        <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
 2004f10:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        <== NOT EXECUTED
 2004f14:	10 80 00 12 	b  2004f5c <rtems_termios_refill_transmitter+0x8c><== NOT EXECUTED
 2004f18:	82 10 60 02 	or  %g1, 2, %g1                                <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
                                                                      
    nToSend = 1;                                                      
                                                                      
  } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
 2004f1c:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
 2004f20:	82 08 60 03 	and  %g1, 3, %g1                               
 2004f24:	80 a0 60 02 	cmp  %g1, 2                                    
 2004f28:	12 80 00 12 	bne  2004f70 <rtems_termios_refill_transmitter+0xa0><== ALWAYS TAKEN
 2004f2c:	92 06 20 49 	add  %i0, 0x49, %o1                            
     * 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);
 2004f30:	c2 06 20 a4 	ld  [ %i0 + 0xa4 ], %g1                        <== NOT EXECUTED
 2004f34:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
 2004f38:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2004f3c:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
 2004f40:	7f ff f5 a1 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2004f44:	01 00 00 00 	nop                                            <== NOT EXECUTED
    tty->t_dqlen--;                                                   
 2004f48:	c2 06 20 90 	ld  [ %i0 + 0x90 ], %g1                        <== NOT EXECUTED
 2004f4c:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
 2004f50:	c2 26 20 90 	st  %g1, [ %i0 + 0x90 ]                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
 2004f54:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        <== NOT EXECUTED
 2004f58:	82 08 7f fd 	and  %g1, -3, %g1                              <== NOT EXECUTED
 2004f5c:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
 2004f60:	7f ff f5 9d 	call  20025d4 <sparc_enable_interrupts>        <== NOT EXECUTED
 2004f64:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
 2004f68:	81 c7 e0 08 	ret                                            
 2004f6c:	81 e8 00 00 	restore                                        
                                                                      
    nToSend = 1;                                                      
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
 2004f70:	c4 06 20 80 	ld  [ %i0 + 0x80 ], %g2                        
 2004f74:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
 2004f78:	80 a0 80 01 	cmp  %g2, %g1                                  
 2004f7c:	12 80 00 0a 	bne  2004fa4 <rtems_termios_refill_transmitter+0xd4>
 2004f80:	01 00 00 00 	nop                                            
      /*                                                              
       * buffer was empty                                             
       */                                                             
      if (tty->rawOutBufState == rob_wait) {                          
 2004f84:	c2 06 20 94 	ld  [ %i0 + 0x94 ], %g1                        
 2004f88:	80 a0 60 02 	cmp  %g1, 2                                    
 2004f8c:	12 bf ff f7 	bne  2004f68 <rtems_termios_refill_transmitter+0x98><== ALWAYS TAKEN
 2004f90:	b0 10 20 00 	clr  %i0                                       
        /*                                                            
         * this should never happen...                                
         */                                                           
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
 2004f94:	40 00 0a 15 	call  20077e8 <rtems_semaphore_release>        <== NOT EXECUTED
 2004f98:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        <== NOT EXECUTED
 2004f9c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2004fa0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      }                                                               
      return 0;                                                       
    }                                                                 
                                                                      
    rtems_interrupt_disable(level);                                   
 2004fa4:	7f ff f5 88 	call  20025c4 <sparc_disable_interrupts>       
 2004fa8:	01 00 00 00 	nop                                            
    len = tty->t_dqlen;                                               
 2004fac:	f8 06 20 90 	ld  [ %i0 + 0x90 ], %i4                        
    tty->t_dqlen = 0;                                                 
 2004fb0:	c0 26 20 90 	clr  [ %i0 + 0x90 ]                            
    rtems_interrupt_enable(level);                                    
 2004fb4:	7f ff f5 88 	call  20025d4 <sparc_enable_interrupts>        
 2004fb8:	01 00 00 00 	nop                                            
                                                                      
    newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;      
 2004fbc:	d0 06 20 84 	ld  [ %i0 + 0x84 ], %o0                        
 2004fc0:	d2 06 20 88 	ld  [ %i0 + 0x88 ], %o1                        
 2004fc4:	40 00 4d f5 	call  2018798 <.urem>                          
 2004fc8:	90 07 00 08 	add  %i4, %o0, %o0                             
    tty->rawOutBuf.Tail = newTail;                                    
    if (tty->rawOutBufState == rob_wait) {                            
 2004fcc:	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;                                    
 2004fd0:	d0 27 60 84 	st  %o0, [ %i5 + 0x84 ]                        
    if (tty->rawOutBufState == rob_wait) {                            
 2004fd4:	80 a0 60 02 	cmp  %g1, 2                                    
 2004fd8:	12 80 00 04 	bne  2004fe8 <rtems_termios_refill_transmitter+0x118>
 2004fdc:	b8 10 00 08 	mov  %o0, %i4                                  
      /*                                                              
       * wake up any pending writer task                              
       */                                                             
      rtems_semaphore_release (tty->rawOutBuf.Semaphore);             
 2004fe0:	40 00 0a 02 	call  20077e8 <rtems_semaphore_release>        
 2004fe4:	d0 06 20 8c 	ld  [ %i0 + 0x8c ], %o0                        
    }                                                                 
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
 2004fe8:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 2004fec:	80 a7 00 01 	cmp  %i4, %g1                                  
 2004ff0:	12 80 00 0b 	bne  200501c <rtems_termios_refill_transmitter+0x14c>
 2004ff4:	01 00 00 00 	nop                                            
      nToSend = 0;                                                    
                                                                      
      /*                                                              
       * check to see if snd wakeup callback was set                  
       */                                                             
      if ( tty->tty_snd.sw_pfn != NULL) {                             
 2004ff8:	c2 07 60 d4 	ld  [ %i5 + 0xd4 ], %g1                        
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
      /*                                                              
       * Buffer has become empty                                      
       */                                                             
      tty->rawOutBufState = rob_idle;                                 
 2004ffc:	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) {                             
 2005000:	80 a0 60 00 	cmp  %g1, 0                                    
 2005004:	02 80 00 29 	be  20050a8 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
 2005008:	b0 10 20 00 	clr  %i0                                       
        (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);   
 200500c:	d2 07 60 d8 	ld  [ %i5 + 0xd8 ], %o1                        <== NOT EXECUTED
 2005010:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2005014:	90 07 60 30 	add  %i5, 0x30, %o0                            <== NOT EXECUTED
 2005018:	30 80 00 24 	b,a   20050a8 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
      }                                                               
    }                                                                 
    /* check, whether output should stop due to received XOFF */      
    else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))               
 200501c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2005020:	82 08 62 10 	and  %g1, 0x210, %g1                           
 2005024:	80 a0 62 10 	cmp  %g1, 0x210                                
 2005028:	12 80 00 0c 	bne  2005058 <rtems_termios_refill_transmitter+0x188><== ALWAYS TAKEN
 200502c:	01 00 00 00 	nop                                            
       ==                (FL_MDXON | FL_ORCVXOF)) {                   
      /* Buffer not empty, but output stops due to XOFF */            
      /* set flag, that output has been stopped */                    
      rtems_interrupt_disable(level);                                 
 2005030:	7f ff f5 65 	call  20025c4 <sparc_disable_interrupts>       <== NOT EXECUTED
 2005034:	01 00 00 00 	nop                                            <== NOT EXECUTED
      tty->flow_ctrl |= FL_OSTOP;                                     
 2005038:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
 200503c:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
 2005040:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
 2005044:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
 2005048:	c2 27 60 94 	st  %g1, [ %i5 + 0x94 ]                        <== NOT EXECUTED
      rtems_interrupt_enable(level);                                  
 200504c:	7f ff f5 62 	call  20025d4 <sparc_enable_interrupts>        <== NOT EXECUTED
 2005050:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
 2005054:	30 80 00 15 	b,a   20050a8 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
      nToSend = 0;                                                    
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
 2005058:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
 200505c:	80 a7 00 01 	cmp  %i4, %g1                                  
 2005060:	08 80 00 04 	bleu  2005070 <rtems_termios_refill_transmitter+0x1a0>
 2005064:	01 00 00 00 	nop                                            
        nToSend = tty->rawOutBuf.Size - newTail;                      
 2005068:	f0 07 60 88 	ld  [ %i5 + 0x88 ], %i0                        
 200506c:	30 80 00 02 	b,a   2005074 <rtems_termios_refill_transmitter+0x1a4>
      else                                                            
        nToSend = tty->rawOutBuf.Head - newTail;                      
 2005070:	f0 07 60 80 	ld  [ %i5 + 0x80 ], %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)) {                   
 2005074:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
 2005078:	80 88 66 00 	btst  0x600, %g1                               
 200507c:	02 80 00 03 	be  2005088 <rtems_termios_refill_transmitter+0x1b8>
 2005080:	b0 26 00 1c 	sub  %i0, %i4, %i0                             
        nToSend = 1;                                                  
 2005084:	b0 10 20 01 	mov  1, %i0                                    
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
 2005088:	82 10 20 01 	mov  1, %g1                                    
      (*tty->device.write)(                                           
 200508c:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        
      /* 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*/                         
 2005090:	c2 27 60 94 	st  %g1, [ %i5 + 0x94 ]                        
      (*tty->device.write)(                                           
 2005094:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
 2005098:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        
 200509c:	92 02 40 1c 	add  %o1, %i4, %o1                             
 20050a0:	9f c0 40 00 	call  %g1                                      
 20050a4:	94 10 00 18 	mov  %i0, %o2                                  
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
 20050a8:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        
  }                                                                   
  return nToSend;                                                     
}                                                                     
 20050ac:	81 c7 e0 08 	ret                                            
 20050b0:	81 e8 00 00 	restore                                        
                                                                      

02006b3c <rtems_termios_rxdaemon>: /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) {
 2006b3c:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
 2006b40:	90 10 20 03 	mov  3, %o0                                    
 2006b44:	92 10 20 02 	mov  2, %o1                                    
 2006b48:	94 10 20 00 	clr  %o2                                       
 2006b4c:	40 00 01 4f 	call  2007088 <rtems_event_receive>            
 2006b50:	96 07 bf fc 	add  %fp, -4, %o3                              
      (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) {              
 2006b54:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2006b58:	80 88 60 01 	btst  1, %g1                                   
 2006b5c:	22 80 00 06 	be,a   2006b74 <rtems_termios_rxdaemon+0x38>   <== ALWAYS TAKEN
 2006b60:	c2 06 20 a0 	ld  [ %i0 + 0xa0 ], %g1                        
      tty->rxTaskId = 0;                                              
 2006b64:	c0 26 20 c4 	clr  [ %i0 + 0xc4 ]                            <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
 2006b68:	40 00 03 ac 	call  2007a18 <rtems_task_delete>              <== NOT EXECUTED
 2006b6c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
 2006b70:	c2 06 20 a0 	ld  [ %i0 + 0xa0 ], %g1                        <== NOT EXECUTED
 2006b74:	9f c0 40 00 	call  %g1                                      
 2006b78:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
    if (c != EOF) {                                                   
 2006b7c:	80 a2 3f ff 	cmp  %o0, -1                                   
 2006b80:	22 bf ff f1 	be,a   2006b44 <rtems_termios_rxdaemon+0x8>    
 2006b84:	90 10 20 03 	mov  3, %o0                                    
      /*                                                              
       * pollRead did call enqueue on its own                         
       */                                                             
      c_buf = c;                                                      
 2006b88:	d0 2f bf fb 	stb  %o0, [ %fp + -5 ]                         
      rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);           
 2006b8c:	92 07 bf fb 	add  %fp, -5, %o1                              
 2006b90:	90 10 00 18 	mov  %i0, %o0                                  
 2006b94:	7f ff ff 2a 	call  200683c <rtems_termios_enqueue_raw_characters>
 2006b98:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
 2006b9c:	10 bf ff ea 	b  2006b44 <rtems_termios_rxdaemon+0x8>        
 2006ba0:	90 10 20 03 	mov  3, %o0                                    
                                                                      

020050b4 <rtems_termios_txdaemon>: /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) {
 20050b4:	9d e3 bf 98 	save  %sp, -104, %sp                           
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
 20050b8:	3b 00 80 74 	sethi  %hi(0x201d000), %i5                     
 20050bc:	ba 17 61 c4 	or  %i5, 0x1c4, %i5	! 201d1c4 <rtems_termios_linesw>
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
 20050c0:	90 10 20 03 	mov  3, %o0                                    
 20050c4:	92 10 20 02 	mov  2, %o1                                    
 20050c8:	94 10 20 00 	clr  %o2                                       
 20050cc:	40 00 07 ef 	call  2007088 <rtems_event_receive>            
 20050d0:	96 07 bf fc 	add  %fp, -4, %o3                              
       (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) {              
 20050d4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20050d8:	80 88 60 01 	btst  1, %g1                                   
 20050dc:	22 80 00 06 	be,a   20050f4 <rtems_termios_txdaemon+0x40>   <== ALWAYS TAKEN
 20050e0:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
      tty->txTaskId = 0;                                              
 20050e4:	c0 26 20 c8 	clr  [ %i0 + 0xc8 ]                            <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
 20050e8:	40 00 0a 4c 	call  2007a18 <rtems_task_delete>              <== NOT EXECUTED
 20050ec:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
 20050f0:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        <== NOT EXECUTED
 20050f4:	83 28 60 05 	sll  %g1, 5, %g1                               
 20050f8:	82 07 40 01 	add  %i5, %g1, %g1                             
 20050fc:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
 2005100:	80 a0 60 00 	cmp  %g1, 0                                    
 2005104:	02 80 00 04 	be  2005114 <rtems_termios_txdaemon+0x60>      <== ALWAYS TAKEN
 2005108:	01 00 00 00 	nop                                            
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
 200510c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
 2005110:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * try to push further characters to device                       
     */                                                               
    rtems_termios_refill_transmitter(tty);                            
 2005114:	7f ff ff 6f 	call  2004ed0 <rtems_termios_refill_transmitter>
 2005118:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
 200511c:	10 bf ff ea 	b  20050c4 <rtems_termios_txdaemon+0x10>       
 2005120:	90 10 20 03 	mov  3, %o0                                    
                                                                      

020063c4 <rtems_termios_write>: rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) {
 20063c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
 20063c8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  rtems_termios_puts (&c, 1, tty);                                    
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_write (void *arg)                                       
{                                                                     
 20063cc:	b8 10 00 18 	mov  %i0, %i4                                  
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
 20063d0:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
 20063d4:	92 10 20 00 	clr  %o1                                       
 20063d8:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
 20063dc:	40 00 04 ba 	call  20076c4 <rtems_semaphore_obtain>         
 20063e0:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
 20063e4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 20063e8:	12 80 00 25 	bne  200647c <rtems_termios_write+0xb8>        <== NEVER TAKEN
 20063ec:	03 00 80 74 	sethi  %hi(0x201d000), %g1                     
    return sc;                                                        
  if (rtems_termios_linesw[tty->t_line].l_write != NULL) {            
 20063f0:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
 20063f4:	85 28 a0 05 	sll  %g2, 5, %g2                               
 20063f8:	82 10 61 c4 	or  %g1, 0x1c4, %g1                            
 20063fc:	82 00 40 02 	add  %g1, %g2, %g1                             
 2006400:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2006404:	80 a0 60 00 	cmp  %g1, 0                                    
 2006408:	02 80 00 06 	be  2006420 <rtems_termios_write+0x5c>         
 200640c:	90 10 00 1d 	mov  %i5, %o0                                  
    sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);         
 2006410:	9f c0 40 00 	call  %g1                                      
 2006414:	92 10 00 1c 	mov  %i4, %o1                                  
 2006418:	10 80 00 17 	b  2006474 <rtems_termios_write+0xb0>          
 200641c:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_semaphore_release (tty->osem);                              
    return sc;                                                        
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
 2006420:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
    uint32_t   count = args->count;                                   
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
 2006424:	b6 10 20 00 	clr  %i3                                       
  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) {                                 
 2006428:	80 88 60 01 	btst  1, %g1                                   
 200642c:	f4 07 20 14 	ld  [ %i4 + 0x14 ], %i2                        
 2006430:	12 80 00 07 	bne  200644c <rtems_termios_write+0x88>        <== ALWAYS TAKEN
 2006434:	f2 07 20 10 	ld  [ %i4 + 0x10 ], %i1                        
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
 2006438:	10 80 00 0a 	b  2006460 <rtems_termios_write+0x9c>          <== NOT EXECUTED
 200643c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
    uint32_t   count = args->count;                                   
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
      oproc (*buffer++, tty);                                         
 2006440:	92 10 00 1d 	mov  %i5, %o1                                  
 2006444:	7f ff fe 54 	call  2005d94 <oproc>                          
 2006448:	b6 06 e0 01 	inc  %i3                                       
    return sc;                                                        
  }                                                                   
  if (tty->termios.c_oflag & OPOST) {                                 
    uint32_t   count = args->count;                                   
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
 200644c:	80 a6 c0 1a 	cmp  %i3, %i2                                  
 2006450:	32 bf ff fc 	bne,a   2006440 <rtems_termios_write+0x7c>     
 2006454:	d0 0e 40 1b 	ldub  [ %i1 + %i3 ], %o0                       
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
    args->bytes_moved = args->count;                                  
 2006458:	10 80 00 06 	b  2006470 <rtems_termios_write+0xac>          
 200645c:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
      oproc (*buffer++, tty);                                         
    args->bytes_moved = args->count;                                  
  } else {                                                            
    rtems_termios_puts (args->buffer, args->count, tty);              
 2006460:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
 2006464:	7f ff fe 03 	call  2005c70 <rtems_termios_puts>             <== NOT EXECUTED
 2006468:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
    args->bytes_moved = args->count;                                  
 200646c:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        <== NOT EXECUTED
 2006470:	c2 27 20 1c 	st  %g1, [ %i4 + 0x1c ]                        
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
 2006474:	40 00 04 dd 	call  20077e8 <rtems_semaphore_release>        
 2006478:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  return sc;                                                          
}                                                                     
 200647c:	81 c7 e0 08 	ret                                            
 2006480:	81 e8 00 00 	restore                                        
                                                                      

02018324 <rtems_timer_cancel>: */ rtems_status_code rtems_timer_cancel( rtems_id id ) {
 2018324:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (                      
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
 2018328:	11 00 80 f4 	sethi  %hi(0x203d000), %o0                     
 201832c:	92 10 00 18 	mov  %i0, %o1                                  
 2018330:	90 12 23 28 	or  %o0, 0x328, %o0                            
 2018334:	40 00 0c 3b 	call  201b420 <_Objects_Get>                   
 2018338:	94 07 bf fc 	add  %fp, -4, %o2                              
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
 201833c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 2018340:	80 a0 60 00 	cmp  %g1, 0                                    
 2018344:	12 80 00 0c 	bne  2018374 <rtems_timer_cancel+0x50>         
 2018348:	01 00 00 00 	nop                                            
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
 201834c:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
 2018350:	80 a0 60 04 	cmp  %g1, 4                                    
 2018354:	02 80 00 04 	be  2018364 <rtems_timer_cancel+0x40>          <== NEVER TAKEN
 2018358:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &the_timer->Ticker );                
 201835c:	40 00 14 07 	call  201d378 <_Watchdog_Remove>               
 2018360:	90 02 20 10 	add  %o0, 0x10, %o0                            
      _Thread_Enable_dispatch();                                      
 2018364:	40 00 10 11 	call  201c3a8 <_Thread_Enable_dispatch>        
 2018368:	b0 10 20 00 	clr  %i0                                       
 201836c:	81 c7 e0 08 	ret                                            
 2018370:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
 2018374:	81 c7 e0 08 	ret                                            
 2018378:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      

02018834 <rtems_timer_server_fire_when>: rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
 2018834:	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;                 
 2018838:	03 00 80 f4 	sethi  %hi(0x203d000), %g1                     
 201883c:	f8 00 63 68 	ld  [ %g1 + 0x368 ], %i4	! 203d368 <_Timer_server>
                                                                      
  if ( !timer_server )                                                
 2018840:	80 a7 20 00 	cmp  %i4, 0                                    
 2018844:	02 80 00 3c 	be  2018934 <rtems_timer_server_fire_when+0x100>
 2018848:	82 10 20 0e 	mov  0xe, %g1                                  
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD.is_set )                                                 
 201884c:	21 00 80 f2 	sethi  %hi(0x203c800), %l0                     
 2018850:	82 14 20 f8 	or  %l0, 0xf8, %g1	! 203c8f8 <_TOD>            
 2018854:	c4 08 60 14 	ldub  [ %g1 + 0x14 ], %g2                      
 2018858:	80 a0 a0 00 	cmp  %g2, 0                                    
 201885c:	02 80 00 36 	be  2018934 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
 2018860:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
 2018864:	80 a6 a0 00 	cmp  %i2, 0                                    
 2018868:	02 80 00 33 	be  2018934 <rtems_timer_server_fire_when+0x100>
 201886c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
 2018870:	7f ff f3 7f 	call  201566c <_TOD_Validate>                  
 2018874:	90 10 00 19 	mov  %i1, %o0                                  
 2018878:	80 8a 20 ff 	btst  0xff, %o0                                
 201887c:	02 80 00 2e 	be  2018934 <rtems_timer_server_fire_when+0x100>
 2018880:	82 10 20 14 	mov  0x14, %g1                                 
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  seconds = _TOD_To_seconds( wall_time );                             
 2018884:	7f ff f3 40 	call  2015584 <_TOD_To_seconds>                
 2018888:	90 10 00 19 	mov  %i1, %o0                                  
 201888c:	b2 10 00 08 	mov  %o0, %i1                                  
 2018890:	d0 1c 20 f8 	ldd  [ %l0 + 0xf8 ], %o0                       
 2018894:	94 10 20 00 	clr  %o2                                       
 2018898:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 201889c:	40 00 4f b7 	call  202c778 <__divdi3>                       
 20188a0:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
 20188a4:	80 a6 40 09 	cmp  %i1, %o1                                  
 20188a8:	08 80 00 23 	bleu  2018934 <rtems_timer_server_fire_when+0x100>
 20188ac:	82 10 20 14 	mov  0x14, %g1                                 
 20188b0:	11 00 80 f4 	sethi  %hi(0x203d000), %o0                     
 20188b4:	92 10 00 18 	mov  %i0, %o1                                  
 20188b8:	90 12 23 28 	or  %o0, 0x328, %o0                            
 20188bc:	40 00 0a d9 	call  201b420 <_Objects_Get>                   
 20188c0:	94 07 bf fc 	add  %fp, -4, %o2                              
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
 20188c4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20188c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20188cc:	12 80 00 19 	bne  2018930 <rtems_timer_server_fire_when+0xfc>
 20188d0:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
 20188d4:	40 00 12 a9 	call  201d378 <_Watchdog_Remove>               
 20188d8:	90 02 20 10 	add  %o0, 0x10, %o0                            
 20188dc:	d0 1c 20 f8 	ldd  [ %l0 + 0xf8 ], %o0                       
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
 20188e0:	82 10 20 03 	mov  3, %g1                                    
 20188e4:	94 10 20 00 	clr  %o2                                       
 20188e8:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 20188ec:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
 20188f0:	f4 27 60 2c 	st  %i2, [ %i5 + 0x2c ]                        
  the_watchdog->id        = id;                                       
 20188f4:	f0 27 60 30 	st  %i0, [ %i5 + 0x30 ]                        
  the_watchdog->user_data = user_data;                                
 20188f8:	f6 27 60 34 	st  %i3, [ %i5 + 0x34 ]                        
 20188fc:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2018900:	40 00 4f 9e 	call  202c778 <__divdi3>                       
 2018904:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
      _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 ); 
 2018908:	c2 07 20 04 	ld  [ %i4 + 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();
 201890c:	92 26 40 09 	sub  %i1, %o1, %o1                             
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
 2018910:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    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();
 2018914:	d2 27 60 1c 	st  %o1, [ %i5 + 0x1c ]                        
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
 2018918:	9f c0 40 00 	call  %g1                                      
 201891c:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
      _Thread_Enable_dispatch();                                      
 2018920:	40 00 0e a2 	call  201c3a8 <_Thread_Enable_dispatch>        
 2018924:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
 2018928:	10 80 00 03 	b  2018934 <rtems_timer_server_fire_when+0x100>
 201892c:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
 2018930:	82 10 20 04 	mov  4, %g1                                    
}                                                                     
 2018934:	81 c7 e0 08 	ret                                            
 2018938:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02003358 <rtems_verror>: static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) {
 2003358:	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) {                               
 200335c:	03 08 00 00 	sethi  %hi(0x20000000), %g1                    
 2003360:	80 8e 00 01 	btst  %i0, %g1                                 
 2003364:	12 80 00 0e 	bne  200339c <rtems_verror+0x44>               
 2003368:	ba 10 00 18 	mov  %i0, %i5                                  
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
 200336c:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
 2003370:	c2 00 60 60 	ld  [ %g1 + 0x60 ], %g1	! 201cc60 <_impure_ptr>
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
 2003374:	39 1c 00 00 	sethi  %hi(0x70000000), %i4                    
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
 2003378:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
 200337c:	40 00 31 bf 	call  200fa78 <fflush>                         
 2003380:	b8 2f 40 1c 	andn  %i5, %i4, %i4                            
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
 2003384:	03 10 00 00 	sethi  %hi(0x40000000), %g1                    
 2003388:	80 8f 40 01 	btst  %i5, %g1                                 
 200338c:	12 80 00 15 	bne  20033e0 <rtems_verror+0x88>               
 2003390:	ba 10 20 00 	clr  %i5                                       
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if (_System_state_Is_multiprocessing)                             
      fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
 2003394:	10 80 00 17 	b  20033f0 <rtems_verror+0x98>                 
 2003398:	37 00 80 73 	sethi  %hi(0x201cc00), %i3                     
  int               local_errno = 0;                                  
  int               chars_written = 0;                                
  rtems_status_code status;                                           
                                                                      
  if (error_flag & RTEMS_ERROR_PANIC) {                               
    if (rtems_panic_in_progress++)                                    
 200339c:	05 00 80 75 	sethi  %hi(0x201d400), %g2                     
 20033a0:	c2 00 a0 40 	ld  [ %g2 + 0x40 ], %g1	! 201d440 <rtems_panic_in_progress>
 20033a4:	86 00 60 01 	add  %g1, 1, %g3                               
 20033a8:	80 a0 60 00 	cmp  %g1, 0                                    
 20033ac:	02 80 00 06 	be  20033c4 <rtems_verror+0x6c>                <== ALWAYS TAKEN
 20033b0:	c6 20 a0 40 	st  %g3, [ %g2 + 0x40 ]                        
   *                                                                  
   * 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;                  
 20033b4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     <== NOT EXECUTED
 20033b8:	c4 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g2	! 201d5d0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
                                                                      
    ++level;                                                          
 20033bc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
    _Thread_Dispatch_disable_level = level;                           
 20033c0:	c4 20 61 d0 	st  %g2, [ %g1 + 0x1d0 ]                       <== NOT EXECUTED
      _Thread_Disable_dispatch();       /* disable task switches */   
                                                                      
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
 20033c4:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 20033c8:	c2 00 60 40 	ld  [ %g1 + 0x40 ], %g1	! 201d440 <rtems_panic_in_progress>
 20033cc:	80 a0 60 02 	cmp  %g1, 2                                    
 20033d0:	04 bf ff e7 	ble  200336c <rtems_verror+0x14>               <== ALWAYS TAKEN
 20033d4:	b0 10 20 00 	clr  %i0                                       
 20033d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 20033dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
    local_errno = errno;                                              
 20033e0:	40 00 30 a3 	call  200f66c <__errno>                        
 20033e4:	01 00 00 00 	nop                                            
 20033e8:	fa 02 00 00 	ld  [ %o0 ], %i5                               
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if (_System_state_Is_multiprocessing)                             
      fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
 20033ec:	37 00 80 73 	sethi  %hi(0x201cc00), %i3                     
 20033f0:	c2 06 e0 60 	ld  [ %i3 + 0x60 ], %g1	! 201cc60 <_impure_ptr>
 20033f4:	92 10 00 19 	mov  %i1, %o1                                  
 20033f8:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
 20033fc:	40 00 45 d3 	call  2014b48 <vfprintf>                       
 2003400:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
  if (status)                                                         
 2003404:	80 a7 20 00 	cmp  %i4, 0                                    
 2003408:	02 80 00 0c 	be  2003438 <rtems_verror+0xe0>                
 200340c:	b0 10 00 08 	mov  %o0, %i0                                  
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
 2003410:	c2 06 e0 60 	ld  [ %i3 + 0x60 ], %g1                        
 2003414:	90 10 00 1c 	mov  %i4, %o0                                  
 2003418:	7f ff ff ca 	call  2003340 <rtems_status_text>              
 200341c:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
 2003420:	13 00 80 6b 	sethi  %hi(0x201ac00), %o1                     
 2003424:	94 10 00 08 	mov  %o0, %o2                                  
 2003428:	92 12 62 20 	or  %o1, 0x220, %o1                            
 200342c:	40 00 32 8f 	call  200fe68 <fprintf>                        
 2003430:	90 10 00 1b 	mov  %i3, %o0                                  
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
 2003434:	b0 06 00 08 	add  %i0, %o0, %i0                             
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
                                                                      
  if (local_errno) {                                                  
 2003438:	80 a7 60 00 	cmp  %i5, 0                                    
 200343c:	22 80 00 1c 	be,a   20034ac <rtems_verror+0x154>            
 2003440:	3b 00 80 73 	sethi  %hi(0x201cc00), %i5                     
    if ((local_errno > 0) && *strerror(local_errno))                  
 2003444:	80 a7 60 00 	cmp  %i5, 0                                    
 2003448:	04 80 00 11 	ble  200348c <rtems_verror+0x134>              
 200344c:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
 2003450:	40 00 36 06 	call  2010c68 <strerror>                       
 2003454:	90 10 00 1d 	mov  %i5, %o0                                  
 2003458:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
 200345c:	80 a0 60 00 	cmp  %g1, 0                                    
 2003460:	02 80 00 0b 	be  200348c <rtems_verror+0x134>               <== NEVER TAKEN
 2003464:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
 2003468:	c2 00 60 60 	ld  [ %g1 + 0x60 ], %g1	! 201cc60 <_impure_ptr>
 200346c:	90 10 00 1d 	mov  %i5, %o0                                  
 2003470:	40 00 35 fe 	call  2010c68 <strerror>                       
 2003474:	f8 00 60 0c 	ld  [ %g1 + 0xc ], %i4                         
 2003478:	13 00 80 6b 	sethi  %hi(0x201ac00), %o1                     
 200347c:	94 10 00 08 	mov  %o0, %o2                                  
 2003480:	92 12 62 30 	or  %o1, 0x230, %o1                            
 2003484:	10 80 00 07 	b  20034a0 <rtems_verror+0x148>                
 2003488:	90 10 00 1c 	mov  %i4, %o0                                  
    else                                                              
      chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
 200348c:	c2 00 60 60 	ld  [ %g1 + 0x60 ], %g1                        
 2003490:	13 00 80 6b 	sethi  %hi(0x201ac00), %o1                     
 2003494:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
 2003498:	92 12 62 40 	or  %o1, 0x240, %o1                            
 200349c:	94 10 00 1d 	mov  %i5, %o2                                  
 20034a0:	40 00 32 72 	call  200fe68 <fprintf>                        
 20034a4:	3b 00 80 73 	sethi  %hi(0x201cc00), %i5                     
 20034a8:	b0 06 00 08 	add  %i0, %o0, %i0                             
  }                                                                   
                                                                      
  chars_written += fprintf(stderr, "\n");                             
 20034ac:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
 20034b0:	13 00 80 6b 	sethi  %hi(0x201ac00), %o1                     
 20034b4:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
 20034b8:	40 00 32 6c 	call  200fe68 <fprintf>                        
 20034bc:	92 12 60 78 	or  %o1, 0x78, %o1                             
                                                                      
  (void) fflush(stderr);                                              
 20034c0:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %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");                             
 20034c4:	b0 06 00 08 	add  %i0, %o0, %i0                             
                                                                      
  (void) fflush(stderr);                                              
 20034c8:	40 00 31 6c 	call  200fa78 <fflush>                         
 20034cc:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
                                                                      
  return chars_written;                                               
}                                                                     
 20034d0:	81 c7 e0 08 	ret                                            
 20034d4:	81 e8 00 00 	restore                                        
                                                                      

02023e88 <scanInt>: /** * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) {
 2023e88:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
 2023e8c:	37 1f ff ff 	sethi  %hi(0x7ffffc00), %i3                    
  int sign = 0;                                                       
 2023e90:	b8 10 20 00 	clr  %i4                                       
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
 2023e94:	b6 16 e3 ff 	or  %i3, 0x3ff, %i3                            
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
 2023e98:	ba 10 20 00 	clr  %i5                                       
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
 2023e9c:	21 00 81 79 	sethi  %hi(0x205e400), %l0                     
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
 2023ea0:	23 00 81 79 	sethi  %hi(0x205e400), %l1                     
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
 2023ea4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
 2023ea8:	82 00 7f ff 	add  %g1, -1, %g1                              
 2023eac:	80 a0 60 00 	cmp  %g1, 0                                    
 2023eb0:	16 80 00 07 	bge  2023ecc <scanInt+0x44>                    <== ALWAYS TAKEN
 2023eb4:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
 2023eb8:	d0 04 23 58 	ld  [ %l0 + 0x358 ], %o0                       <== NOT EXECUTED
 2023ebc:	40 00 61 5c 	call  203c42c <__srget_r>                      <== NOT EXECUTED
 2023ec0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
    if (c == ':')                                                     
 2023ec4:	10 80 00 07 	b  2023ee0 <scanInt+0x58>                      <== NOT EXECUTED
 2023ec8:	80 a2 20 3a 	cmp  %o0, 0x3a                                 <== NOT EXECUTED
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
 2023ecc:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 2023ed0:	d0 08 80 00 	ldub  [ %g2 ], %o0                             
 2023ed4:	84 00 a0 01 	inc  %g2                                       
 2023ed8:	c4 26 00 00 	st  %g2, [ %i0 ]                               
    if (c == ':')                                                     
 2023edc:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
 2023ee0:	02 80 00 21 	be  2023f64 <scanInt+0xdc>                     
 2023ee4:	80 a7 20 00 	cmp  %i4, 0                                    
      break;                                                          
    if (sign == 0) {                                                  
 2023ee8:	12 80 00 08 	bne  2023f08 <scanInt+0x80>                    
 2023eec:	c4 04 63 48 	ld  [ %l1 + 0x348 ], %g2                       
      if (c == '-') {                                                 
 2023ef0:	80 a2 20 2d 	cmp  %o0, 0x2d                                 
 2023ef4:	12 80 00 05 	bne  2023f08 <scanInt+0x80>                    
 2023ef8:	b8 10 20 01 	mov  1, %i4                                    
        sign = -1;                                                    
        limit++;                                                      
 2023efc:	b6 06 e0 01 	inc  %i3                                       
        continue;                                                     
 2023f00:	10 bf ff e9 	b  2023ea4 <scanInt+0x1c>                      
 2023f04:	b8 10 3f ff 	mov  -1, %i4                                   
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
 2023f08:	84 00 80 08 	add  %g2, %o0, %g2                             
 2023f0c:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
 2023f10:	80 88 a0 04 	btst  4, %g2                                   
 2023f14:	02 80 00 1d 	be  2023f88 <scanInt+0x100>                    
 2023f18:	b4 02 3f d0 	add  %o0, -48, %i2                             
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
 2023f1c:	92 10 20 0a 	mov  0xa, %o1                                  
 2023f20:	40 00 af de 	call  204fe98 <.udiv>                          
 2023f24:	90 10 00 1b 	mov  %i3, %o0                                  
 2023f28:	80 a7 40 08 	cmp  %i5, %o0                                  
 2023f2c:	38 80 00 15 	bgu,a   2023f80 <scanInt+0xf8>                 
 2023f30:	b0 10 20 00 	clr  %i0                                       
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
 2023f34:	12 80 00 08 	bne  2023f54 <scanInt+0xcc>                    
 2023f38:	83 2f 60 01 	sll  %i5, 1, %g1                               
 2023f3c:	90 10 00 1b 	mov  %i3, %o0                                  
 2023f40:	40 00 b0 82 	call  2050148 <.urem>                          
 2023f44:	92 10 20 0a 	mov  0xa, %o1                                  
 2023f48:	80 a6 80 08 	cmp  %i2, %o0                                  
 2023f4c:	18 80 00 0f 	bgu  2023f88 <scanInt+0x100>                   <== ALWAYS TAKEN
 2023f50:	83 2f 60 01 	sll  %i5, 1, %g1                               
      return 0;                                                       
    i = i * 10 + d;                                                   
 2023f54:	bb 2f 60 03 	sll  %i5, 3, %i5                               
 2023f58:	ba 00 40 1d 	add  %g1, %i5, %i5                             
 2023f5c:	10 bf ff d2 	b  2023ea4 <scanInt+0x1c>                      
 2023f60:	ba 06 80 1d 	add  %i2, %i5, %i5                             
  }                                                                   
  if (sign == 0)                                                      
 2023f64:	02 80 00 07 	be  2023f80 <scanInt+0xf8>                     <== NEVER TAKEN
 2023f68:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
  *val = i * sign;                                                    
 2023f6c:	90 10 00 1c 	mov  %i4, %o0                                  
 2023f70:	92 10 00 1d 	mov  %i5, %o1                                  
 2023f74:	40 00 af 8f 	call  204fdb0 <.umul>                          
 2023f78:	b0 10 20 01 	mov  1, %i0                                    
 2023f7c:	d0 26 40 00 	st  %o0, [ %i1 ]                               
  return 1;                                                           
 2023f80:	81 c7 e0 08 	ret                                            
 2023f84:	81 e8 00 00 	restore                                        
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
 2023f88:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
  if (sign == 0)                                                      
    return 0;                                                         
  *val = i * sign;                                                    
  return 1;                                                           
}                                                                     
 2023f8c:	81 c7 e0 08 	ret                                            
 2023f90:	81 e8 00 00 	restore                                        
                                                                      

02024084 <scangr>: FILE *fp, struct group *grp, char *buffer, size_t bufsize ) {
 2024084:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
 2024088:	98 10 20 00 	clr  %o4                                       
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
 202408c:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
 2024090:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
 2024094:	90 10 00 18 	mov  %i0, %o0                                  
 2024098:	92 10 00 19 	mov  %i1, %o1                                  
 202409c:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 20240a0:	7f ff ff bd 	call  2023f94 <scanString>                     
 20240a4:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 20240a8:	80 a2 20 00 	cmp  %o0, 0                                    
 20240ac:	12 80 00 04 	bne  20240bc <scangr+0x38>                     
 20240b0:	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;                                                         
 20240b4:	81 c7 e0 08 	ret                                            
 20240b8:	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)          
 20240bc:	92 06 60 04 	add  %i1, 4, %o1                               
 20240c0:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 20240c4:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 20240c8:	7f ff ff b3 	call  2023f94 <scanString>                     
 20240cc:	98 10 20 00 	clr  %o4                                       
 20240d0:	80 a2 20 00 	cmp  %o0, 0                                    
 20240d4:	02 bf ff f8 	be  20240b4 <scangr+0x30>                      <== NEVER TAKEN
 20240d8:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &grgid)                                            
 20240dc:	7f ff ff 6b 	call  2023e88 <scanInt>                        
 20240e0:	92 07 bf f8 	add  %fp, -8, %o1                              
 20240e4:	80 a2 20 00 	cmp  %o0, 0                                    
 20240e8:	02 bf ff f3 	be  20240b4 <scangr+0x30>                      <== NEVER TAKEN
 20240ec:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
 20240f0:	92 07 bf fc 	add  %fp, -4, %o1                              
 20240f4:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 20240f8:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 20240fc:	7f ff ff a6 	call  2023f94 <scanString>                     
 2024100:	98 10 20 01 	mov  1, %o4                                    
 2024104:	80 a2 20 00 	cmp  %o0, 0                                    
 2024108:	02 bf ff eb 	be  20240b4 <scangr+0x30>                      <== NEVER TAKEN
 202410c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
 2024110:	c6 07 bf fc 	ld  [ %fp + -4 ], %g3                          
  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;                                                
 2024114:	c2 36 60 08 	sth  %g1, [ %i1 + 8 ]                          
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
 2024118:	84 10 00 03 	mov  %g3, %g2                                  
 202411c:	10 80 00 05 	b  2024130 <scangr+0xac>                       
 2024120:	82 10 20 01 	mov  1, %g1                                    
 2024124:	84 00 a0 01 	inc  %g2                                       
    if(*cp == ',')                                                    
      memcount++;                                                     
 2024128:	80 a0 00 04 	cmp  %g0, %g4                                  
 202412c:	82 60 7f ff 	subx  %g1, -1, %g1                             
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
 2024130:	c8 48 80 00 	ldsb  [ %g2 ], %g4                             
 2024134:	80 a1 20 00 	cmp  %g4, 0                                    
 2024138:	32 bf ff fb 	bne,a   2024124 <scangr+0xa0>                  
 202413c:	88 19 20 2c 	xor  %g4, 0x2c, %g4                            
  }                                                                   
                                                                      
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
 2024140:	c4 07 a0 50 	ld  [ %fp + 0x50 ], %g2                        
 2024144:	83 28 60 02 	sll  %g1, 2, %g1                               
 2024148:	82 00 60 13 	add  %g1, 0x13, %g1                            
 202414c:	80 a0 80 01 	cmp  %g2, %g1                                  
 2024150:	0a bf ff d9 	bcs  20240b4 <scangr+0x30>                     <== NEVER TAKEN
 2024154:	c2 07 a0 4c 	ld  [ %fp + 0x4c ], %g1                        
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
 2024158:	84 10 20 01 	mov  1, %g2                                    
  /*                                                                  
   * Hack to produce (hopefully) a suitably-aligned array of pointers 
   */                                                                 
  if (bufsize < (((memcount+1)*sizeof(char *)) + 15))                 
    return 0;                                                         
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
 202415c:	82 00 60 0f 	add  %g1, 0xf, %g1                             
 2024160:	82 08 7f f0 	and  %g1, -16, %g1                             
 2024164:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
 2024168:	c6 20 40 00 	st  %g3, [ %g1 ]                               
}                                                                     
                                                                      
/**                                                                   
 *  Extract a single group record from the database                   
 */                                                                   
static int scangr(                                                    
 202416c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
 2024170:	10 80 00 0a 	b  2024198 <scangr+0x114>                      
 2024174:	82 00 60 01 	inc  %g1                                       
    if(*cp == ',') {                                                  
 2024178:	32 80 00 08 	bne,a   2024198 <scangr+0x114>                 
 202417c:	82 00 60 01 	inc  %g1                                       
      *cp = '\0';                                                     
 2024180:	c0 28 7f ff 	clrb  [ %g1 + -1 ]                             
      grp->gr_mem[memcount++] = cp + 1;                               
 2024184:	c8 06 60 0c 	ld  [ %i1 + 0xc ], %g4                         
 2024188:	87 28 a0 02 	sll  %g2, 2, %g3                               
 202418c:	84 00 a0 01 	inc  %g2                                       
 2024190:	c2 21 00 03 	st  %g1, [ %g4 + %g3 ]                         
 2024194:	82 00 60 01 	inc  %g1                                       
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
 2024198:	c6 48 7f ff 	ldsb  [ %g1 + -1 ], %g3                        
 202419c:	80 a0 e0 00 	cmp  %g3, 0                                    
 20241a0:	32 bf ff f6 	bne,a   2024178 <scangr+0xf4>                  
 20241a4:	80 a0 e0 2c 	cmp  %g3, 0x2c                                 
    if(*cp == ',') {                                                  
      *cp = '\0';                                                     
      grp->gr_mem[memcount++] = cp + 1;                               
    }                                                                 
  }                                                                   
  grp->gr_mem[memcount] = NULL;                                       
 20241a8:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
 20241ac:	85 28 a0 02 	sll  %g2, 2, %g2                               
 20241b0:	c0 20 40 02 	clr  [ %g1 + %g2 ]                             
  return 1;                                                           
}                                                                     
 20241b4:	81 c7 e0 08 	ret                                            
 20241b8:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

020241bc <scanpw>: FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) {
 20241bc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
 20241c0:	98 10 20 00 	clr  %o4                                       
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
 20241c4:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
 20241c8:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
 20241cc:	90 10 00 18 	mov  %i0, %o0                                  
 20241d0:	92 10 00 19 	mov  %i1, %o1                                  
 20241d4:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 20241d8:	7f ff ff 6f 	call  2023f94 <scanString>                     
 20241dc:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 20241e0:	80 a2 20 00 	cmp  %o0, 0                                    
 20241e4:	12 80 00 04 	bne  20241f4 <scanpw+0x38>                     
 20241e8:	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;                                                         
 20241ec:	81 c7 e0 08 	ret                                            
 20241f0:	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)          
 20241f4:	92 06 60 04 	add  %i1, 4, %o1                               
 20241f8:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 20241fc:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 2024200:	7f ff ff 65 	call  2023f94 <scanString>                     
 2024204:	98 10 20 00 	clr  %o4                                       
 2024208:	80 a2 20 00 	cmp  %o0, 0                                    
 202420c:	02 bf ff f8 	be  20241ec <scanpw+0x30>                      <== NEVER TAKEN
 2024210:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &pwuid)                                            
 2024214:	7f ff ff 1d 	call  2023e88 <scanInt>                        
 2024218:	92 07 bf f8 	add  %fp, -8, %o1                              
 202421c:	80 a2 20 00 	cmp  %o0, 0                                    
 2024220:	02 bf ff f3 	be  20241ec <scanpw+0x30>                      
 2024224:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &pwgid)                                            
 2024228:	7f ff ff 18 	call  2023e88 <scanInt>                        
 202422c:	92 07 bf fc 	add  %fp, -4, %o1                              
 2024230:	80 a2 20 00 	cmp  %o0, 0                                    
 2024234:	02 bf ff ee 	be  20241ec <scanpw+0x30>                      
 2024238:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
 202423c:	92 06 60 0c 	add  %i1, 0xc, %o1                             
 2024240:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 2024244:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 2024248:	7f ff ff 53 	call  2023f94 <scanString>                     
 202424c:	98 10 20 00 	clr  %o4                                       
 2024250:	80 a2 20 00 	cmp  %o0, 0                                    
 2024254:	02 bf ff e6 	be  20241ec <scanpw+0x30>                      <== NEVER TAKEN
 2024258:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
 202425c:	92 06 60 10 	add  %i1, 0x10, %o1                            
 2024260:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 2024264:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 2024268:	7f ff ff 4b 	call  2023f94 <scanString>                     
 202426c:	98 10 20 00 	clr  %o4                                       
 2024270:	80 a2 20 00 	cmp  %o0, 0                                    
 2024274:	02 bf ff de 	be  20241ec <scanpw+0x30>                      <== NEVER TAKEN
 2024278:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)             
 202427c:	92 06 60 14 	add  %i1, 0x14, %o1                            
 2024280:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 2024284:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 2024288:	7f ff ff 43 	call  2023f94 <scanString>                     
 202428c:	98 10 20 00 	clr  %o4                                       
 2024290:	80 a2 20 00 	cmp  %o0, 0                                    
 2024294:	02 bf ff d6 	be  20241ec <scanpw+0x30>                      <== NEVER TAKEN
 2024298:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))          
 202429c:	92 06 60 18 	add  %i1, 0x18, %o1                            
 20242a0:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
 20242a4:	96 07 a0 50 	add  %fp, 0x50, %o3                            
 20242a8:	7f ff ff 3b 	call  2023f94 <scanString>                     
 20242ac:	98 10 20 01 	mov  1, %o4                                    
 20242b0:	80 a2 20 00 	cmp  %o0, 0                                    
 20242b4:	02 bf ff ce 	be  20241ec <scanpw+0x30>                      
 20242b8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
    return 0;                                                         
  pwd->pw_uid = pwuid;                                                
 20242bc:	c2 36 60 08 	sth  %g1, [ %i1 + 8 ]                          
  pwd->pw_gid = pwgid;                                                
 20242c0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20242c4:	c2 36 60 0a 	sth  %g1, [ %i1 + 0xa ]                        
  return 1;                                                           
}                                                                     
 20242c8:	81 c7 e0 08 	ret                                            
 20242cc:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

02007d24 <sched_get_priority_max>: #include <rtems/posix/priority.h> int sched_get_priority_max( int policy ) {
 2007d24:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( policy ) {                                                 
 2007d28:	80 a6 20 04 	cmp  %i0, 4                                    
 2007d2c:	18 80 00 06 	bgu  2007d44 <sched_get_priority_max+0x20>     
 2007d30:	82 10 20 01 	mov  1, %g1                                    
 2007d34:	b1 28 40 18 	sll  %g1, %i0, %i0                             
 2007d38:	80 8e 20 17 	btst  0x17, %i0                                
 2007d3c:	12 80 00 08 	bne  2007d5c <sched_get_priority_max+0x38>     <== ALWAYS TAKEN
 2007d40:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
 2007d44:	40 00 21 79 	call  2010328 <__errno>                        
 2007d48:	b0 10 3f ff 	mov  -1, %i0                                   
 2007d4c:	82 10 20 16 	mov  0x16, %g1                                 
 2007d50:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2007d54:	81 c7 e0 08 	ret                                            
 2007d58:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MAXIMUM_PRIORITY;                            
 2007d5c:	f0 08 63 6c 	ldub  [ %g1 + 0x36c ], %i0                     
}                                                                     
 2007d60:	81 c7 e0 08 	ret                                            
 2007d64:	91 ee 3f ff 	restore  %i0, -1, %o0                          
                                                                      

02007d68 <sched_get_priority_min>: * 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258 */ int sched_get_priority_min( int policy ) {
 2007d68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( policy ) {                                                 
 2007d6c:	80 a6 20 04 	cmp  %i0, 4                                    
 2007d70:	18 80 00 06 	bgu  2007d88 <sched_get_priority_min+0x20>     
 2007d74:	82 10 20 01 	mov  1, %g1                                    
 2007d78:	83 28 40 18 	sll  %g1, %i0, %g1                             
 2007d7c:	80 88 60 17 	btst  0x17, %g1                                
 2007d80:	12 80 00 06 	bne  2007d98 <sched_get_priority_min+0x30>     <== ALWAYS TAKEN
 2007d84:	b0 10 20 01 	mov  1, %i0                                    
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
 2007d88:	40 00 21 68 	call  2010328 <__errno>                        
 2007d8c:	b0 10 3f ff 	mov  -1, %i0                                   
 2007d90:	82 10 20 16 	mov  0x16, %g1                                 
 2007d94:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MINIMUM_PRIORITY;                            
}                                                                     
 2007d98:	81 c7 e0 08 	ret                                            
 2007d9c:	81 e8 00 00 	restore                                        
                                                                      

02007da0 <sched_rr_get_interval>: int sched_rr_get_interval( pid_t pid, struct timespec *interval ) {
 2007da0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid && pid != getpid() )                                       
 2007da4:	80 a6 20 00 	cmp  %i0, 0                                    
 2007da8:	02 80 00 0b 	be  2007dd4 <sched_rr_get_interval+0x34>       <== NEVER TAKEN
 2007dac:	80 a6 60 00 	cmp  %i1, 0                                    
 2007db0:	7f ff ef 87 	call  2003bcc <getpid>                         
 2007db4:	01 00 00 00 	nop                                            
 2007db8:	80 a6 00 08 	cmp  %i0, %o0                                  
 2007dbc:	02 80 00 06 	be  2007dd4 <sched_rr_get_interval+0x34>       
 2007dc0:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
 2007dc4:	40 00 21 59 	call  2010328 <__errno>                        
 2007dc8:	01 00 00 00 	nop                                            
 2007dcc:	10 80 00 07 	b  2007de8 <sched_rr_get_interval+0x48>        
 2007dd0:	82 10 20 03 	mov  3, %g1	! 3 <PROM_START+0x3>               
                                                                      
  if ( !interval )                                                    
 2007dd4:	12 80 00 08 	bne  2007df4 <sched_rr_get_interval+0x54>      
 2007dd8:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
    rtems_set_errno_and_return_minus_one( EINVAL );                   
 2007ddc:	40 00 21 53 	call  2010328 <__errno>                        
 2007de0:	01 00 00 00 	nop                                            
 2007de4:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2007de8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2007dec:	81 c7 e0 08 	ret                                            
 2007df0:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      
  _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );      
 2007df4:	d0 00 63 60 	ld  [ %g1 + 0x360 ], %o0                       
 2007df8:	92 10 00 19 	mov  %i1, %o1                                  
 2007dfc:	40 00 0e c2 	call  200b904 <_Timespec_From_ticks>           
 2007e00:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
 2007e04:	81 c7 e0 08 	ret                                            
 2007e08:	81 e8 00 00 	restore                                        
                                                                      

020084bc <sem_open>: int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) {
 20084bc:	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;                  
 20084c0:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
 20084c4:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2	! 2022090 <_Thread_Dispatch_disable_level>
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
 20084c8:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
                                                                      
    ++level;                                                          
 20084cc:	84 00 a0 01 	inc  %g2                                       
 20084d0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
 20084d4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
 20084d8:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    _Thread_Dispatch_disable_level = level;                           
 20084dc:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
  Objects_Locations          location;                                
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
 20084e0:	b4 8e 62 00 	andcc  %i1, 0x200, %i2                         
 20084e4:	02 80 00 05 	be  20084f8 <sem_open+0x3c>                    
 20084e8:	b8 10 20 00 	clr  %i4                                       
    va_start(arg, oflag);                                             
    mode = va_arg( arg, mode_t );                                     
    value = va_arg( arg, unsigned int );                              
 20084ec:	f8 07 a0 50 	ld  [ %fp + 0x50 ], %i4                        
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
 20084f0:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
 20084f4:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]                         
  const char *name,                                                   
  Objects_Id *id,                                                     
  size_t     *len                                                     
)                                                                     
{                                                                     
  return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
 20084f8:	37 00 80 88 	sethi  %hi(0x2022000), %i3                     
 20084fc:	92 10 00 18 	mov  %i0, %o1                                  
 2008500:	90 16 e3 64 	or  %i3, 0x364, %o0                            
 2008504:	94 07 bf f0 	add  %fp, -16, %o2                             
 2008508:	7f ff fe 7e 	call  2007f00 <_POSIX_Name_to_id>              
 200850c:	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 ) {                                                     
 2008510:	ba 92 20 00 	orcc  %o0, 0, %i5                              
 2008514:	22 80 00 0e 	be,a   200854c <sem_open+0x90>                 
 2008518:	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) ) ) {               
 200851c:	80 a7 60 02 	cmp  %i5, 2                                    
 2008520:	12 80 00 04 	bne  2008530 <sem_open+0x74>                   
 2008524:	80 a6 a0 00 	cmp  %i2, 0                                    
 2008528:	12 80 00 20 	bne  20085a8 <sem_open+0xec>                   
 200852c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
      _Thread_Enable_dispatch();                                      
 2008530:	40 00 0d ee 	call  200bce8 <_Thread_Enable_dispatch>        
 2008534:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( status, sem_t * );   
 2008538:	40 00 24 16 	call  2011590 <__errno>                        
 200853c:	01 00 00 00 	nop                                            
 2008540:	fa 22 00 00 	st  %i5, [ %o0 ]                               
 2008544:	81 c7 e0 08 	ret                                            
 2008548:	81 e8 00 00 	restore                                        
                                                                      
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
                                                                      
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
 200854c:	80 a6 6a 00 	cmp  %i1, 0xa00                                
 2008550:	12 80 00 0a 	bne  2008578 <sem_open+0xbc>                   
 2008554:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
      _Thread_Enable_dispatch();                                      
 2008558:	40 00 0d e4 	call  200bce8 <_Thread_Enable_dispatch>        
 200855c:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );   
 2008560:	40 00 24 0c 	call  2011590 <__errno>                        
 2008564:	01 00 00 00 	nop                                            
 2008568:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
 200856c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2008570:	81 c7 e0 08 	ret                                            
 2008574:	81 e8 00 00 	restore                                        
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (  
  sem_t             *id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (POSIX_Semaphore_Control *)                                  
 2008578:	94 07 bf f8 	add  %fp, -8, %o2                              
 200857c:	40 00 09 ea 	call  200ad24 <_Objects_Get>                   
 2008580:	90 16 e3 64 	or  %i3, 0x364, %o0                            
    }                                                                 
                                                                      
    the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
    the_semaphore->open_count += 1;                                   
 2008584:	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 );
 2008588:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
    the_semaphore->open_count += 1;                                   
 200858c:	82 00 60 01 	inc  %g1                                       
    _Thread_Enable_dispatch();                                        
 2008590:	40 00 0d d6 	call  200bce8 <_Thread_Enable_dispatch>        
 2008594:	c2 22 20 18 	st  %g1, [ %o0 + 0x18 ]                        
    _Thread_Enable_dispatch();                                        
 2008598:	40 00 0d d4 	call  200bce8 <_Thread_Enable_dispatch>        
 200859c:	01 00 00 00 	nop                                            
    goto return_id;                                                   
 20085a0:	10 80 00 0d 	b  20085d4 <sem_open+0x118>                    
 20085a4:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
  /*                                                                  
   *  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(                            
 20085a8:	94 10 20 00 	clr  %o2                                       
 20085ac:	96 10 00 1c 	mov  %i4, %o3                                  
 20085b0:	98 07 bf f4 	add  %fp, -12, %o4                             
 20085b4:	40 00 19 b1 	call  200ec78 <_POSIX_Semaphore_Create_support>
 20085b8:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
                                                                      
  _Thread_Enable_dispatch();                                          
 20085bc:	40 00 0d cb 	call  200bce8 <_Thread_Enable_dispatch>        
 20085c0:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( status == -1 )                                                 
 20085c4:	80 a7 7f ff 	cmp  %i5, -1                                   
 20085c8:	22 80 00 04 	be,a   20085d8 <sem_open+0x11c>                <== NEVER TAKEN
 20085cc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
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;                        
 20085d0:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
 20085d4:	b0 06 20 08 	add  %i0, 8, %i0                               
  #endif                                                              
}                                                                     
 20085d8:	81 c7 e0 08 	ret                                            
 20085dc:	81 e8 00 00 	restore                                        
                                                                      

02007d1c <sigaction>: int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) {
 2007d1c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level     level;                                                
                                                                      
  if ( oact )                                                         
 2007d20:	80 a6 a0 00 	cmp  %i2, 0                                    
 2007d24:	02 80 00 0a 	be  2007d4c <sigaction+0x30>                   
 2007d28:	83 2e 20 02 	sll  %i0, 2, %g1                               
    *oact = _POSIX_signals_Vectors[ sig ];                            
 2007d2c:	85 2e 20 04 	sll  %i0, 4, %g2                               
 2007d30:	82 20 80 01 	sub  %g2, %g1, %g1                             
 2007d34:	13 00 80 84 	sethi  %hi(0x2021000), %o1                     
 2007d38:	90 10 00 1a 	mov  %i2, %o0                                  
 2007d3c:	92 12 60 c0 	or  %o1, 0xc0, %o1                             
 2007d40:	94 10 20 0c 	mov  0xc, %o2                                  
 2007d44:	40 00 24 db 	call  20110b0 <memcpy>                         
 2007d48:	92 02 40 01 	add  %o1, %g1, %o1                             
                                                                      
  if ( !sig )                                                         
 2007d4c:	80 a6 20 00 	cmp  %i0, 0                                    
 2007d50:	32 80 00 03 	bne,a   2007d5c <sigaction+0x40>               
 2007d54:	82 06 3f ff 	add  %i0, -1, %g1                              
 2007d58:	30 80 00 06 	b,a   2007d70 <sigaction+0x54>                 
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
 2007d5c:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
 2007d60:	18 80 00 04 	bgu  2007d70 <sigaction+0x54>                  
 2007d64:	80 a6 20 09 	cmp  %i0, 9                                    
   *                                                                  
   *  NOTE: Solaris documentation claims to "silently enforce" this which
   *        contradicts the POSIX specification.                      
   */                                                                 
                                                                      
  if ( sig == SIGKILL )                                               
 2007d68:	12 80 00 08 	bne  2007d88 <sigaction+0x6c>                  
 2007d6c:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
 2007d70:	40 00 22 7b 	call  201075c <__errno>                        
 2007d74:	01 00 00 00 	nop                                            
 2007d78:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2007d7c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2007d80:	10 80 00 20 	b  2007e00 <sigaction+0xe4>                    
 2007d84:	82 10 3f ff 	mov  -1, %g1                                   
  /*                                                                  
   *  Evaluate the new action structure and set the global signal vector
   *  appropriately.                                                  
   */                                                                 
                                                                      
  if ( act ) {                                                        
 2007d88:	02 80 00 1e 	be  2007e00 <sigaction+0xe4>                   <== NEVER TAKEN
 2007d8c:	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 );                                            
 2007d90:	7f ff ea f1 	call  2002954 <sparc_disable_interrupts>       
 2007d94:	01 00 00 00 	nop                                            
 2007d98:	b8 10 00 08 	mov  %o0, %i4                                  
      if ( act->sa_handler == SIG_DFL ) {                             
 2007d9c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 2007da0:	3b 00 80 84 	sethi  %hi(0x2021000), %i5                     
 2007da4:	80 a0 60 00 	cmp  %g1, 0                                    
 2007da8:	12 80 00 0a 	bne  2007dd0 <sigaction+0xb4>                  
 2007dac:	ba 17 60 c0 	or  %i5, 0xc0, %i5                             
        _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
 2007db0:	83 2e 20 02 	sll  %i0, 2, %g1                               
 2007db4:	13 00 80 7b 	sethi  %hi(0x201ec00), %o1                     
 2007db8:	b1 2e 20 04 	sll  %i0, 4, %i0                               
 2007dbc:	92 12 60 4c 	or  %o1, 0x4c, %o1                             
 2007dc0:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2007dc4:	90 07 40 18 	add  %i5, %i0, %o0                             
 2007dc8:	10 80 00 09 	b  2007dec <sigaction+0xd0>                    
 2007dcc:	92 02 40 18 	add  %o1, %i0, %o1                             
      } else {                                                        
         _POSIX_signals_Clear_process_signals( sig );                 
 2007dd0:	40 00 17 07 	call  200d9ec <_POSIX_signals_Clear_process_signals>
 2007dd4:	90 10 00 18 	mov  %i0, %o0                                  
         _POSIX_signals_Vectors[ sig ] = *act;                        
 2007dd8:	83 2e 20 02 	sll  %i0, 2, %g1                               
 2007ddc:	92 10 00 19 	mov  %i1, %o1                                  
 2007de0:	b1 2e 20 04 	sll  %i0, 4, %i0                               
 2007de4:	90 26 00 01 	sub  %i0, %g1, %o0                             
 2007de8:	90 07 40 08 	add  %i5, %o0, %o0                             
 2007dec:	40 00 24 b1 	call  20110b0 <memcpy>                         
 2007df0:	94 10 20 0c 	mov  0xc, %o2                                  
      }                                                               
    _ISR_Enable( level );                                             
 2007df4:	7f ff ea dc 	call  2002964 <sparc_enable_interrupts>        
 2007df8:	90 10 00 1c 	mov  %i4, %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;                                                           
 2007dfc:	82 10 20 00 	clr  %g1                                       
}                                                                     
 2007e00:	81 c7 e0 08 	ret                                            
 2007e04:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

02008260 <sigtimedwait>: int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) {
 2008260:	9d e3 bf 90 	save  %sp, -112, %sp                           
  ISR_Level          level;                                           
                                                                      
  /*                                                                  
   *  Error check parameters before disabling interrupts.             
   */                                                                 
  if ( !set )                                                         
 2008264:	80 a6 20 00 	cmp  %i0, 0                                    
 2008268:	02 80 00 0e 	be  20082a0 <sigtimedwait+0x40>                
 200826c:	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 ) {                                                    
 2008270:	02 80 00 10 	be  20082b0 <sigtimedwait+0x50>                
 2008274:	b6 10 20 00 	clr  %i3                                       
                                                                      
    if ( !_Timespec_Is_valid( timeout ) )                             
 2008278:	40 00 0f 0b 	call  200bea4 <_Timespec_Is_valid>             
 200827c:	90 10 00 1a 	mov  %i2, %o0                                  
 2008280:	80 8a 20 ff 	btst  0xff, %o0                                
 2008284:	02 80 00 07 	be  20082a0 <sigtimedwait+0x40>                
 2008288:	01 00 00 00 	nop                                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    interval = _Timespec_To_ticks( timeout );                         
 200828c:	40 00 0f 18 	call  200beec <_Timespec_To_ticks>             
 2008290:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    if ( !interval )                                                  
 2008294:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 2008298:	12 80 00 07 	bne  20082b4 <sigtimedwait+0x54>               <== ALWAYS TAKEN
 200829c:	80 a6 60 00 	cmp  %i1, 0                                    
      rtems_set_errno_and_return_minus_one( EINVAL );                 
 20082a0:	40 00 22 fb 	call  2010e8c <__errno>                        
 20082a4:	01 00 00 00 	nop                                            
 20082a8:	10 80 00 63 	b  2008434 <sigtimedwait+0x1d4>                
 20082ac:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
 20082b0:	80 a6 60 00 	cmp  %i1, 0                                    
 20082b4:	22 80 00 02 	be,a   20082bc <sigtimedwait+0x5c>             
 20082b8:	b2 07 bf f4 	add  %fp, -12, %i1                             
                                                                      
  the_thread = _Thread_Executing;                                     
 20082bc:	21 00 80 85 	sethi  %hi(0x2021400), %l0                     
 20082c0:	a0 14 21 40 	or  %l0, 0x140, %l0	! 2021540 <_Per_CPU_Information>
 20082c4:	fa 04 20 10 	ld  [ %l0 + 0x10 ], %i5                        
   *  What if they are already pending?                               
   */                                                                 
                                                                      
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
 20082c8:	7f ff ea 80 	call  2002cc8 <sparc_disable_interrupts>       
 20082cc:	f8 07 61 5c 	ld  [ %i5 + 0x15c ], %i4                       
 20082d0:	b4 10 00 08 	mov  %o0, %i2                                  
  if ( *set & api->signals_pending ) {                                
 20082d4:	c4 06 00 00 	ld  [ %i0 ], %g2                               
 20082d8:	c2 07 20 d4 	ld  [ %i4 + 0xd4 ], %g1                        
 20082dc:	80 88 80 01 	btst  %g2, %g1                                 
 20082e0:	22 80 00 12 	be,a   2008328 <sigtimedwait+0xc8>             
 20082e4:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
    /* XXX real info later */                                         
    the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
 20082e8:	7f ff ff c6 	call  2008200 <_POSIX_signals_Get_lowest>      
 20082ec:	90 10 00 01 	mov  %g1, %o0                                  
    _POSIX_signals_Clear_signals(                                     
 20082f0:	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 );
 20082f4:	92 10 00 08 	mov  %o0, %o1                                  
 20082f8:	d0 26 40 00 	st  %o0, [ %i1 ]                               
    _POSIX_signals_Clear_signals(                                     
 20082fc:	96 10 20 00 	clr  %o3                                       
 2008300:	90 10 00 1c 	mov  %i4, %o0                                  
 2008304:	40 00 17 d5 	call  200e258 <_POSIX_signals_Clear_signals>   
 2008308:	98 10 20 00 	clr  %o4                                       
      the_info->si_signo,                                             
      the_info,                                                       
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
 200830c:	7f ff ea 73 	call  2002cd8 <sparc_enable_interrupts>        
 2008310:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    the_info->si_code = SI_USER;                                      
 2008314:	82 10 20 01 	mov  1, %g1                                    
    the_info->si_value.sival_int = 0;                                 
 2008318:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
                                                                      
    the_info->si_code = SI_USER;                                      
 200831c:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
    the_info->si_value.sival_int = 0;                                 
    return the_info->si_signo;                                        
 2008320:	10 80 00 47 	b  200843c <sigtimedwait+0x1dc>                
 2008324:	fa 06 40 00 	ld  [ %i1 ], %i5                               
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
 2008328:	c2 00 63 94 	ld  [ %g1 + 0x394 ], %g1                       
 200832c:	80 88 80 01 	btst  %g2, %g1                                 
 2008330:	22 80 00 12 	be,a   2008378 <sigtimedwait+0x118>            
 2008334:	82 10 3f ff 	mov  -1, %g1                                   
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
 2008338:	7f ff ff b2 	call  2008200 <_POSIX_signals_Get_lowest>      
 200833c:	90 10 00 01 	mov  %g1, %o0                                  
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
 2008340:	94 10 00 19 	mov  %i1, %o2                                  
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
 2008344:	ba 10 00 08 	mov  %o0, %i5                                  
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
 2008348:	96 10 20 01 	mov  1, %o3                                    
 200834c:	90 10 00 1c 	mov  %i4, %o0                                  
 2008350:	92 10 00 1d 	mov  %i5, %o1                                  
 2008354:	40 00 17 c1 	call  200e258 <_POSIX_signals_Clear_signals>   
 2008358:	98 10 20 00 	clr  %o4                                       
    _ISR_Enable( level );                                             
 200835c:	7f ff ea 5f 	call  2002cd8 <sparc_enable_interrupts>        
 2008360:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    the_info->si_signo = signo;                                       
    the_info->si_code = SI_USER;                                      
 2008364:	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;                                       
 2008368:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    the_info->si_code = SI_USER;                                      
 200836c:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
    the_info->si_value.sival_int = 0;                                 
 2008370:	10 80 00 33 	b  200843c <sigtimedwait+0x1dc>                
 2008374:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
    return signo;                                                     
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
 2008378:	c2 26 40 00 	st  %g1, [ %i1 ]                               
   *                                                                  
   * 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;                  
 200837c:	03 00 80 84 	sethi  %hi(0x2021000), %g1                     
 2008380:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2	! 2021020 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
 2008384:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 2008388:	c4 20 60 20 	st  %g2, [ %g1 + 0x20 ]                        
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
    the_thread->Wait.return_code     = EINTR;                         
 200838c:	82 10 20 04 	mov  4, %g1                                    
 2008390:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
    the_thread->Wait.option          = *set;                          
 2008394:	c2 06 00 00 	ld  [ %i0 ], %g1                               
    the_thread->Wait.return_argument = the_info;                      
 2008398:	f2 27 60 28 	st  %i1, [ %i5 + 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;                          
 200839c:	c2 27 60 30 	st  %g1, [ %i5 + 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;
 20083a0:	a2 10 20 01 	mov  1, %l1                                    
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
 20083a4:	35 00 80 85 	sethi  %hi(0x2021400), %i2                     
 20083a8:	b4 16 a3 2c 	or  %i2, 0x32c, %i2	! 202172c <_POSIX_signals_Wait_queue>
 20083ac:	f4 27 60 44 	st  %i2, [ %i5 + 0x44 ]                        
 20083b0:	e2 26 a0 30 	st  %l1, [ %i2 + 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 );                                             
 20083b4:	7f ff ea 49 	call  2002cd8 <sparc_enable_interrupts>        
 20083b8:	01 00 00 00 	nop                                            
    _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );    
 20083bc:	90 10 00 1a 	mov  %i2, %o0                                  
 20083c0:	92 10 00 1b 	mov  %i3, %o1                                  
 20083c4:	15 00 80 2f 	sethi  %hi(0x200bc00), %o2                     
 20083c8:	40 00 0d 60 	call  200b948 <_Thread_queue_Enqueue_with_handler>
 20083cc:	94 12 a0 b4 	or  %o2, 0xb4, %o2	! 200bcb4 <_Thread_queue_Timeout>
  _Thread_Enable_dispatch();                                          
 20083d0:	40 00 0c 19 	call  200b434 <_Thread_Enable_dispatch>        
 20083d4:	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 );
 20083d8:	d2 06 40 00 	ld  [ %i1 ], %o1                               
 20083dc:	90 10 00 1c 	mov  %i4, %o0                                  
 20083e0:	94 10 00 19 	mov  %i1, %o2                                  
 20083e4:	96 10 20 00 	clr  %o3                                       
 20083e8:	40 00 17 9c 	call  200e258 <_POSIX_signals_Clear_signals>   
 20083ec:	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)                 
 20083f0:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        
 20083f4:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
 20083f8:	80 a0 60 04 	cmp  %g1, 4                                    
 20083fc:	12 80 00 09 	bne  2008420 <sigtimedwait+0x1c0>              
 2008400:	01 00 00 00 	nop                                            
       || !(*set & signo_to_mask( the_info->si_signo )) ) {           
 2008404:	fa 06 40 00 	ld  [ %i1 ], %i5                               
 2008408:	82 07 7f ff 	add  %i5, -1, %g1                              
 200840c:	a3 2c 40 01 	sll  %l1, %g1, %l1                             
 2008410:	c2 06 00 00 	ld  [ %i0 ], %g1                               
 2008414:	80 8c 40 01 	btst  %l1, %g1                                 
 2008418:	12 80 00 09 	bne  200843c <sigtimedwait+0x1dc>              
 200841c:	01 00 00 00 	nop                                            
    errno = _Thread_Executing->Wait.return_code;                      
 2008420:	40 00 22 9b 	call  2010e8c <__errno>                        
 2008424:	01 00 00 00 	nop                                            
 2008428:	03 00 80 85 	sethi  %hi(0x2021400), %g1                     
 200842c:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1	! 2021550 <_Per_CPU_Information+0x10>
 2008430:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
 2008434:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return -1;                                                        
 2008438:	ba 10 3f ff 	mov  -1, %i5                                   
  }                                                                   
                                                                      
  return the_info->si_signo;                                          
}                                                                     
 200843c:	81 c7 e0 08 	ret                                            
 2008440:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
                                                                      

0200a178 <sigwait>: int sigwait( const sigset_t *set, int *sig ) {
 200a178:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int status;                                                         
                                                                      
  status = sigtimedwait( set, NULL, NULL );                           
 200a17c:	92 10 20 00 	clr  %o1                                       
 200a180:	90 10 00 18 	mov  %i0, %o0                                  
 200a184:	7f ff ff 80 	call  2009f84 <sigtimedwait>                   
 200a188:	94 10 20 00 	clr  %o2                                       
                                                                      
  if ( status != -1 ) {                                               
 200a18c:	80 a2 3f ff 	cmp  %o0, -1                                   
 200a190:	02 80 00 06 	be  200a1a8 <sigwait+0x30>                     
 200a194:	80 a6 60 00 	cmp  %i1, 0                                    
    if ( sig )                                                        
 200a198:	32 80 00 09 	bne,a   200a1bc <sigwait+0x44>                 <== ALWAYS TAKEN
 200a19c:	d0 26 40 00 	st  %o0, [ %i1 ]                               
      *sig = status;                                                  
    return 0;                                                         
 200a1a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200a1a4:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
  }                                                                   
                                                                      
  return errno;                                                       
 200a1a8:	40 00 21 cb 	call  20128d4 <__errno>                        
 200a1ac:	01 00 00 00 	nop                                            
 200a1b0:	f0 02 00 00 	ld  [ %o0 ], %i0                               
 200a1b4:	81 c7 e0 08 	ret                                            
 200a1b8:	81 e8 00 00 	restore                                        
  status = sigtimedwait( set, NULL, NULL );                           
                                                                      
  if ( status != -1 ) {                                               
    if ( sig )                                                        
      *sig = status;                                                  
    return 0;                                                         
 200a1bc:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  return errno;                                                       
}                                                                     
 200a1c0:	81 c7 e0 08 	ret                                            
 200a1c4:	81 e8 00 00 	restore                                        
                                                                      

0200637c <siproc>: /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) {
 200637c:	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)) {
 2006380:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
 2006384:	80 88 6e 78 	btst  0xe78, %g1                               
 2006388:	02 80 00 0d 	be  20063bc <siproc+0x40>                      <== NEVER TAKEN
 200638c:	94 10 20 00 	clr  %o2                                       
    rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 
 2006390:	d0 06 60 18 	ld  [ %i1 + 0x18 ], %o0                        
 2006394:	40 00 04 cc 	call  20076c4 <rtems_semaphore_obtain>         
 2006398:	92 10 20 00 	clr  %o1                                       
    i = iproc (c, tty);                                               
 200639c:	90 10 00 18 	mov  %i0, %o0                                  
 20063a0:	7f ff ff 6b 	call  200614c <iproc>                          
 20063a4:	92 10 00 19 	mov  %i1, %o1                                  
 20063a8:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_semaphore_release (tty->osem);                              
 20063ac:	40 00 05 0f 	call  20077e8 <rtems_semaphore_release>        
 20063b0:	d0 06 60 18 	ld  [ %i1 + 0x18 ], %o0                        
 20063b4:	81 c7 e0 08 	ret                                            
 20063b8:	81 e8 00 00 	restore                                        
  }                                                                   
  else {                                                              
    i = iproc (c, tty);                                               
 20063bc:	7f ff ff 64 	call  200614c <iproc>                          <== NOT EXECUTED
 20063c0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

0200ebc0 <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 ) {
 200ebc0:	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 ) {                                 
 200ebc4:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
 200ebc8:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <RAM_END+0xbdd84201>
 200ebcc:	80 a6 40 01 	cmp  %i1, %g1                                  
 200ebd0:	12 80 00 7f 	bne  200edcc <sparse_disk_ioctl+0x20c>         
 200ebd4:	fa 06 20 3c 	ld  [ %i0 + 0x3c ], %i5                        
    rtems_blkdev_request *r = argp;                                   
                                                                      
    switch ( r->req ) {                                               
 200ebd8:	e8 06 80 00 	ld  [ %i2 ], %l4                               
 200ebdc:	80 a5 20 01 	cmp  %l4, 1                                    
 200ebe0:	18 80 00 95 	bgu  200ee34 <sparse_disk_ioctl+0x274>         <== NEVER TAKEN
 200ebe4:	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 );
 200ebe8:	d0 07 40 00 	ld  [ %i5 ], %o0                               
 200ebec:	94 10 20 00 	clr  %o2                                       
 200ebf0:	7f ff eb 25 	call  2009884 <rtems_semaphore_obtain>         
 200ebf4:	25 00 80 3a 	sethi  %hi(0x200e800), %l2                     
static int sparse_disk_read_write(                                    
  rtems_sparse_disk    *sparse_disk,                                  
  rtems_blkdev_request *req,                                          
  const bool            read )                                        
{                                                                     
  int                     rv = 0;                                     
 200ebf8:	b6 10 20 00 	clr  %i3                                       
  size_t                  buff_size;                                  
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
 200ebfc:	b0 10 20 00 	clr  %i0                                       
                                                                      
  /* 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(                                                      
 200ec00:	10 80 00 63 	b  200ed8c <sparse_disk_ioctl+0x1cc>           
 200ec04:	a4 14 a3 8c 	or  %l2, 0x38c, %l2                            
  for ( req_buffer = 0;                                               
        ( 0 <= rv ) && ( req_buffer < req->bufnum );                  
        ++req_buffer ) {                                              
    scatter_gather = &req->bufs[req_buffer];                          
                                                                      
    bytes_handled  = 0;                                               
 200ec08:	a6 10 20 00 	clr  %l3                                       
  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];                          
 200ec0c:	84 00 a0 18 	add  %g2, 0x18, %g2                            
 200ec10:	82 06 80 02 	add  %i2, %g2, %g1                             
                                                                      
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
 200ec14:	f2 06 80 02 	ld  [ %i2 + %g2 ], %i1                         
        ( 0 <= rv ) && ( req_buffer < req->bufnum );                  
        ++req_buffer ) {                                              
    scatter_gather = &req->bufs[req_buffer];                          
                                                                      
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
 200ec18:	ea 00 60 08 	ld  [ %g1 + 8 ], %l5                           
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
 200ec1c:	10 80 00 54 	b  200ed6c <sparse_disk_ioctl+0x1ac>           
 200ec20:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
  const rtems_blkdev_bnum  block,                                     
  uint8_t                 *buffer,                                    
  const size_t             buffer_size )                              
{                                                                     
  rtems_sparse_disk_key *key;                                         
  rtems_sparse_disk_key  block_key = {                                
 200ec24:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    .block = block,                                                   
    .data  = NULL                                                     
  };                                                                  
  size_t                 bytes_to_copy = sparse_disk->media_block_size;
 200ec28:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
      if ( read )                                                     
 200ec2c:	80 a5 20 00 	cmp  %l4, 0                                    
 200ec30:	12 80 00 1a 	bne  200ec98 <sparse_disk_ioctl+0xd8>          
 200ec34:	a2 05 40 13 	add  %l5, %l3, %l1                             
 200ec38:	80 a7 00 01 	cmp  %i4, %g1                                  
 200ec3c:	08 80 00 03 	bleu  200ec48 <sparse_disk_ioctl+0x88>         
 200ec40:	b6 10 00 1c 	mov  %i4, %i3                                  
 200ec44:	b6 10 00 01 	mov  %g1, %i3                                  
  size_t                 bytes_to_copy = sparse_disk->media_block_size;
                                                                      
  if ( buffer_size < bytes_to_copy )                                  
    bytes_to_copy = buffer_size;                                      
                                                                      
  key = bsearch(                                                      
 200ec48:	d2 07 60 18 	ld  [ %i5 + 0x18 ], %o1                        
 200ec4c:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
 200ec50:	90 07 bf f8 	add  %fp, -8, %o0                              
 200ec54:	96 10 20 08 	mov  8, %o3                                    
 200ec58:	40 00 32 33 	call  201b524 <bsearch>                        
 200ec5c:	98 10 00 12 	mov  %l2, %o4                                  
 200ec60:	82 10 00 08 	mov  %o0, %g1                                  
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL != key )                                                  
 200ec64:	80 a0 60 00 	cmp  %g1, 0                                    
 200ec68:	02 80 00 07 	be  200ec84 <sparse_disk_ioctl+0xc4>           
 200ec6c:	90 10 00 11 	mov  %l1, %o0                                  
    memcpy( buffer, key->data, bytes_to_copy );                       
 200ec70:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           
 200ec74:	40 00 35 0d 	call  201c0a8 <memcpy>                         
 200ec78:	94 10 00 1b 	mov  %i3, %o2                                  
        rv = sparse_disk_write_block( sparse_disk,                    
                                      block,                          
                                      &buff[bytes_handled],           
                                      buff_size );                    
                                                                      
      ++block;                                                        
 200ec7c:	10 80 00 3a 	b  200ed64 <sparse_disk_ioctl+0x1a4>           
 200ec80:	b2 06 60 01 	inc  %i1                                       
    );                                                                
                                                                      
  if ( NULL != key )                                                  
    memcpy( buffer, key->data, bytes_to_copy );                       
  else                                                                
    memset( buffer, sparse_disk->fill_pattern, buffer_size );         
 200ec84:	d2 0f 60 14 	ldub  [ %i5 + 0x14 ], %o1                      
 200ec88:	40 00 35 45 	call  201c19c <memset>                         
 200ec8c:	94 10 00 1c 	mov  %i4, %o2                                  
        rv = sparse_disk_write_block( sparse_disk,                    
                                      block,                          
                                      &buff[bytes_handled],           
                                      buff_size );                    
                                                                      
      ++block;                                                        
 200ec90:	10 80 00 35 	b  200ed64 <sparse_disk_ioctl+0x1a4>           
 200ec94:	b2 06 60 01 	inc  %i1                                       
 200ec98:	80 a7 00 01 	cmp  %i4, %g1                                  
 200ec9c:	08 80 00 03 	bleu  200eca8 <sparse_disk_ioctl+0xe8>         
 200eca0:	a0 10 00 1c 	mov  %i4, %l0                                  
 200eca4:	a0 10 00 01 	mov  %g1, %l0                                  
                                                                      
  /* 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(                                                      
 200eca8:	d2 07 60 18 	ld  [ %i5 + 0x18 ], %o1                        
 200ecac:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
 200ecb0:	90 07 bf f8 	add  %fp, -8, %o0                              
 200ecb4:	96 10 20 08 	mov  8, %o3                                    
 200ecb8:	40 00 32 1b 	call  201b524 <bsearch>                        
 200ecbc:	98 10 00 12 	mov  %l2, %o4                                  
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
 200ecc0:	b6 92 20 00 	orcc  %o0, 0, %i3                              
 200ecc4:	32 80 00 23 	bne,a   200ed50 <sparse_disk_ioctl+0x190>      
 200ecc8:	d0 06 e0 04 	ld  [ %i3 + 4 ], %o0                           
 200eccc:	10 80 00 08 	b  200ecec <sparse_disk_ioctl+0x12c>           
 200ecd0:	84 10 20 00 	clr  %g2                                       
    for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
      if ( buffer[i] != sparse_disk->fill_pattern )                   
 200ecd4:	c4 0f 60 14 	ldub  [ %i5 + 0x14 ], %g2                      
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
    for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
 200ecd8:	82 00 60 01 	inc  %g1                                       
      if ( buffer[i] != sparse_disk->fill_pattern )                   
 200ecdc:	84 18 c0 02 	xor  %g3, %g2, %g2                             
 200ece0:	80 a0 00 02 	cmp  %g0, %g2                                  
 200ece4:	10 80 00 03 	b  200ecf0 <sparse_disk_ioctl+0x130>           
 200ece8:	84 40 20 00 	addx  %g0, 0, %g2                              
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
 200ecec:	82 10 20 00 	clr  %g1                                       
    for ( i = 0; ( !block_needs_writing ) && ( i < bytes_to_copy ); ++i ) {
 200ecf0:	80 a0 40 10 	cmp  %g1, %l0                                  
 200ecf4:	1a 80 00 05 	bcc  200ed08 <sparse_disk_ioctl+0x148>         
 200ecf8:	86 18 a0 01 	xor  %g2, 1, %g3                               
 200ecfc:	80 88 e0 ff 	btst  0xff, %g3                                
 200ed00:	32 bf ff f5 	bne,a   200ecd4 <sparse_disk_ioctl+0x114>      
 200ed04:	c6 0c 40 01 	ldub  [ %l1 + %g1 ], %g3                       
      if ( buffer[i] != sparse_disk->fill_pattern )                   
        block_needs_writing = true;                                   
    }                                                                 
                                                                      
    if ( block_needs_writing ) {                                      
 200ed08:	80 88 a0 ff 	btst  0xff, %g2                                
 200ed0c:	22 80 00 15 	be,a   200ed60 <sparse_disk_ioctl+0x1a0>       
 200ed10:	b6 10 00 10 	mov  %l0, %i3                                  
  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 ) {  
 200ed14:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
 200ed18:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
 200ed1c:	80 a2 40 01 	cmp  %o1, %g1                                  
 200ed20:	1a 80 00 10 	bcc  200ed60 <sparse_disk_ioctl+0x1a0>         <== NEVER TAKEN
 200ed24:	b6 10 3f ff 	mov  -1, %i3                                   
    key        = &sparse_disk->key_table[sparse_disk->used_count];    
 200ed28:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
 200ed2c:	83 2a 60 03 	sll  %o1, 3, %g1                               
    key->block = block;                                               
 200ed30:	f2 22 00 01 	st  %i1, [ %o0 + %g1 ]                         
    ++sparse_disk->used_count;                                        
 200ed34:	92 02 60 01 	inc  %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];    
 200ed38:	b6 02 00 01 	add  %o0, %g1, %i3                             
    key->block = block;                                               
    ++sparse_disk->used_count;                                        
 200ed3c:	d2 27 60 08 	st  %o1, [ %i5 + 8 ]                           
    qsort( sparse_disk->key_table, sparse_disk->used_count,           
 200ed40:	94 10 20 08 	mov  8, %o2                                    
 200ed44:	40 00 35 5c 	call  201c2b4 <qsort>                          
 200ed48:	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 );                       
 200ed4c:	d0 06 e0 04 	ld  [ %i3 + 4 ], %o0                           
 200ed50:	92 10 00 11 	mov  %l1, %o1                                  
 200ed54:	40 00 34 d5 	call  201c0a8 <memcpy>                         
 200ed58:	94 10 00 10 	mov  %l0, %o2                                  
  else if ( block_needs_writing )                                     
    return -1;                                                        
                                                                      
  return bytes_to_copy;                                               
 200ed5c:	b6 10 00 10 	mov  %l0, %i3                                  
        rv = sparse_disk_write_block( sparse_disk,                    
                                      block,                          
                                      &buff[bytes_handled],           
                                      buff_size );                    
                                                                      
      ++block;                                                        
 200ed60:	b2 06 60 01 	inc  %i1                                       
      bytes_handled += rv;                                            
 200ed64:	a6 04 c0 1b 	add  %l3, %i3, %l3                             
      buff_size     -= rv;                                            
 200ed68:	b8 27 00 1b 	sub  %i4, %i3, %i4                             
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
 200ed6c:	80 a7 20 00 	cmp  %i4, 0                                    
 200ed70:	02 80 00 04 	be  200ed80 <sparse_disk_ioctl+0x1c0>          
 200ed74:	80 a6 e0 00 	cmp  %i3, 0                                    
 200ed78:	36 bf ff ab 	bge,a   200ec24 <sparse_disk_ioctl+0x64>       <== ALWAYS TAKEN
 200ed7c:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
  size_t                  buff_size;                                  
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
 200ed80:	80 a6 e0 00 	cmp  %i3, 0                                    
 200ed84:	06 80 00 06 	bl  200ed9c <sparse_disk_ioctl+0x1dc>          <== NEVER TAKEN
 200ed88:	b0 06 20 01 	inc  %i0                                       
        ( 0 <= rv ) && ( req_buffer < req->bufnum );                  
 200ed8c:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
 200ed90:	80 a6 00 01 	cmp  %i0, %g1                                  
 200ed94:	0a bf ff 9d 	bcs  200ec08 <sparse_disk_ioctl+0x48>          
 200ed98:	85 2e 20 04 	sll  %i0, 4, %g2                               
      bytes_handled += rv;                                            
      buff_size     -= rv;                                            
    }                                                                 
  }                                                                   
                                                                      
  rtems_semaphore_release( sparse_disk->mutex );                      
 200ed9c:	7f ff eb 03 	call  20099a8 <rtems_semaphore_release>        
 200eda0:	d0 07 40 00 	ld  [ %i5 ], %o0                               
static inline void rtems_blkdev_request_done(                         
  rtems_blkdev_request *req,                                          
  rtems_status_code status                                            
)                                                                     
{                                                                     
  (*req->done)(req, status);                                          
 200eda4:	90 10 00 1a 	mov  %i2, %o0                                  
 200eda8:	92 10 20 1b 	mov  0x1b, %o1                                 
                                                                      
  if ( 0 > rv )                                                       
 200edac:	80 a6 e0 00 	cmp  %i3, 0                                    
 200edb0:	06 80 00 03 	bl  200edbc <sparse_disk_ioctl+0x1fc>          <== NEVER TAKEN
 200edb4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
 200edb8:	92 10 20 00 	clr  %o1                                       
 200edbc:	9f c0 40 00 	call  %g1                                      
 200edc0:	b0 10 20 00 	clr  %i0                                       
 200edc4:	81 c7 e0 08 	ret                                            
 200edc8:	81 e8 00 00 	restore                                        
      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 ) {                          
 200edcc:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
 200edd0:	82 10 62 07 	or  %g1, 0x207, %g1	! 20004207 <RAM_END+0x1dc04207>
 200edd4:	80 a6 40 01 	cmp  %i1, %g1                                  
 200edd8:	12 80 00 12 	bne  200ee20 <sparse_disk_ioctl+0x260>         
 200eddc:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_semaphore_delete( sd->mutex );                         
 200ede0:	7f ff ea 7a 	call  20097c8 <rtems_semaphore_delete>         
 200ede4:	d0 07 40 00 	ld  [ %i5 ], %o0                               
                                                                      
    if ( RTEMS_SUCCESSFUL != sc )                                     
 200ede8:	80 a2 20 00 	cmp  %o0, 0                                    
 200edec:	22 80 00 05 	be,a   200ee00 <sparse_disk_ioctl+0x240>       <== ALWAYS TAKEN
 200edf0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
      rtems_fatal_error_occurred( 0xdeadbeef );                       
 200edf4:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    <== NOT EXECUTED
 200edf8:	7f ff ec 8e 	call  200a030 <rtems_fatal_error_occurred>     <== NOT EXECUTED
 200edfc:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
                                                                      
    sd->mutex = RTEMS_ID_NONE;                                        
 200ee00:	c0 27 40 00 	clr  [ %i5 ]                                   
                                                                      
    if ( NULL != sd->delete_handler )                                 
 200ee04:	80 a0 60 00 	cmp  %g1, 0                                    
 200ee08:	02 bf ff ef 	be  200edc4 <sparse_disk_ioctl+0x204>          <== NEVER TAKEN
 200ee0c:	b0 10 20 00 	clr  %i0                                       
      ( *sd->delete_handler )( sd );                                  
 200ee10:	9f c0 40 00 	call  %g1                                      
 200ee14:	90 10 00 1d 	mov  %i5, %o0                                  
 200ee18:	81 c7 e0 08 	ret                                            
 200ee1c:	81 e8 00 00 	restore                                        
                                                                      
    return 0;                                                         
  } else {                                                            
    return rtems_blkdev_ioctl( dd, req, argp );                       
 200ee20:	92 10 00 19 	mov  %i1, %o1                                  
 200ee24:	40 00 0b 2f 	call  2011ae0 <rtems_blkdev_ioctl>             
 200ee28:	94 10 00 1a 	mov  %i2, %o2                                  
 200ee2c:	81 c7 e0 08 	ret                                            
 200ee30:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  }                                                                   
                                                                      
  errno = EINVAL;                                                     
 200ee34:	40 00 31 de 	call  201b5ac <__errno>                        <== NOT EXECUTED
 200ee38:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
 200ee3c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
 200ee40:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  return -1;                                                          
}                                                                     
 200ee44:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 200ee48:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

02005d14 <sync_per_thread>: fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) {
 2005d14:	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;                                        
 2005d18:	c4 06 21 54 	ld  [ %i0 + 0x154 ], %g2                       
   if ( this_reent ) {                                                
 2005d1c:	80 a0 a0 00 	cmp  %g2, 0                                    
 2005d20:	02 80 00 0c 	be  2005d50 <sync_per_thread+0x3c>             <== NEVER TAKEN
 2005d24:	3b 00 80 7d 	sethi  %hi(0x201f400), %i5                     
     current_reent = _Thread_Executing->libc_reent;                   
 2005d28:	ba 17 60 30 	or  %i5, 0x30, %i5	! 201f430 <_Per_CPU_Information>
 2005d2c:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
     _Thread_Executing->libc_reent = this_reent;                      
     _fwalk (t->libc_reent, sync_wrapper);                            
 2005d30:	13 00 80 17 	sethi  %hi(0x2005c00), %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;                   
 2005d34:	f8 00 61 54 	ld  [ %g1 + 0x154 ], %i4                       
     _Thread_Executing->libc_reent = this_reent;                      
 2005d38:	c4 20 61 54 	st  %g2, [ %g1 + 0x154 ]                       
     _fwalk (t->libc_reent, sync_wrapper);                            
 2005d3c:	d0 06 21 54 	ld  [ %i0 + 0x154 ], %o0                       
 2005d40:	40 00 2d b1 	call  2011404 <_fwalk>                         
 2005d44:	92 12 61 58 	or  %o1, 0x158, %o1                            
     _Thread_Executing->libc_reent = current_reent;                   
 2005d48:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
 2005d4c:	f8 20 61 54 	st  %i4, [ %g1 + 0x154 ]                       
 2005d50:	81 c7 e0 08 	ret                                            
 2005d54:	81 e8 00 00 	restore                                        
                                                                      

02006ff4 <sysconf>: */ long sysconf( int name ) {
 2006ff4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( name == _SC_CLK_TCK )                                          
 2006ff8:	80 a6 20 02 	cmp  %i0, 2                                    
 2006ffc:	12 80 00 09 	bne  2007020 <sysconf+0x2c>                    
 2007000:	03 00 80 73 	sethi  %hi(0x201cc00), %g1                     
    return (TOD_MICROSECONDS_PER_SECOND /                             
 2007004:	03 00 80 6a 	sethi  %hi(0x201a800), %g1                     
 2007008:	d2 00 63 d4 	ld  [ %g1 + 0x3d4 ], %o1	! 201abd4 <Configuration+0xc>
 200700c:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
 2007010:	40 00 45 fb 	call  20187fc <.udiv>                          
 2007014:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
 2007018:	81 c7 e0 08 	ret                                            
 200701c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
      rtems_configuration_get_microseconds_per_tick());               
                                                                      
  if ( name == _SC_OPEN_MAX )                                         
 2007020:	80 a6 20 04 	cmp  %i0, 4                                    
 2007024:	02 80 00 13 	be  2007070 <sysconf+0x7c>                     
 2007028:	d0 00 61 78 	ld  [ %g1 + 0x178 ], %o0                       
    return rtems_libio_number_iops;                                   
                                                                      
  if ( name == _SC_GETPW_R_SIZE_MAX )                                 
 200702c:	80 a6 20 33 	cmp  %i0, 0x33                                 
 2007030:	02 80 00 10 	be  2007070 <sysconf+0x7c>                     
 2007034:	90 10 24 00 	mov  0x400, %o0                                
    return 1024;                                                      
                                                                      
  if ( name == _SC_PAGESIZE )                                         
 2007038:	80 a6 20 08 	cmp  %i0, 8                                    
 200703c:	02 80 00 0d 	be  2007070 <sysconf+0x7c>                     
 2007040:	11 00 00 04 	sethi  %hi(0x1000), %o0                        
    return PAGE_SIZE;                                                 
                                                                      
  if ( name == _SC_SYMLOOP_MAX )                                      
 2007044:	80 a6 20 4f 	cmp  %i0, 0x4f                                 
 2007048:	02 80 00 0a 	be  2007070 <sysconf+0x7c>                     <== NEVER TAKEN
 200704c:	90 10 20 20 	mov  0x20, %o0                                 
    return RTEMS_FILESYSTEM_SYMLOOP_MAX;                              
                                                                      
#if defined(__sparc__)                                                
  if ( name == 515 ) /* Solaris _SC_STACK_PROT */                     
 2007050:	80 a6 22 03 	cmp  %i0, 0x203                                
 2007054:	02 80 00 07 	be  2007070 <sysconf+0x7c>                     <== NEVER TAKEN
 2007058:	90 10 20 00 	clr  %o0                                       
   return 0;                                                          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
 200705c:	40 00 22 49 	call  200f980 <__errno>                        
 2007060:	01 00 00 00 	nop                                            
 2007064:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2007068:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 200706c:	90 10 3f ff 	mov  -1, %o0                                   
}                                                                     
 2007070:	b0 10 00 08 	mov  %o0, %i0                                  
 2007074:	81 c7 e0 08 	ret                                            
 2007078:	81 e8 00 00 	restore                                        
                                                                      

02012f28 <tcsetattr>: int tcsetattr( int fd, int opt, struct termios *tp ) {
 2012f28:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch (opt) {                                                      
 2012f2c:	80 a6 60 00 	cmp  %i1, 0                                    
 2012f30:	02 80 00 10 	be  2012f70 <tcsetattr+0x48>                   
 2012f34:	80 a6 60 01 	cmp  %i1, 1                                    
 2012f38:	02 80 00 08 	be  2012f58 <tcsetattr+0x30>                   
 2012f3c:	90 10 00 18 	mov  %i0, %o0                                  
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
 2012f40:	40 00 10 e3 	call  20172cc <__errno>                        
 2012f44:	b0 10 3f ff 	mov  -1, %i0                                   
 2012f48:	82 10 20 86 	mov  0x86, %g1                                 
 2012f4c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2012f50:	81 c7 e0 08 	ret                                            
 2012f54:	81 e8 00 00 	restore                                        
                                                                      
  case TCSADRAIN:                                                     
    if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)                      
 2012f58:	92 10 20 03 	mov  3, %o1                                    
 2012f5c:	40 00 0d de 	call  20166d4 <ioctl>                          
 2012f60:	94 10 20 00 	clr  %o2                                       
 2012f64:	80 a2 20 00 	cmp  %o0, 0                                    
 2012f68:	26 80 00 04 	bl,a   2012f78 <tcsetattr+0x50>                <== NEVER TAKEN
 2012f6c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
 2012f70:	40 00 0d d9 	call  20166d4 <ioctl>                          
 2012f74:	93 e8 20 02 	restore  %g0, 2, %o1                           
  }                                                                   
}                                                                     
 2012f78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
 2012f7c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

020085e0 <timer_create>: int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) {
 20085e0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  POSIX_Timer_Control *ptimer;                                        
                                                                      
  if ( clock_id != CLOCK_REALTIME )                                   
 20085e4:	80 a6 20 01 	cmp  %i0, 1                                    
 20085e8:	12 80 00 13 	bne  2008634 <timer_create+0x54>               
 20085ec:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !timerid )                                                     
 20085f0:	02 80 00 11 	be  2008634 <timer_create+0x54>                
 20085f4:	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) {                                                  
 20085f8:	02 80 00 13 	be  2008644 <timer_create+0x64>                
 20085fc:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
    /* The structure has data */                                      
    if ( ( evp->sigev_notify != SIGEV_NONE ) &&                       
 2008600:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 2008604:	82 00 7f ff 	add  %g1, -1, %g1                              
 2008608:	80 a0 60 01 	cmp  %g1, 1                                    
 200860c:	28 80 00 03 	bleu,a   2008618 <timer_create+0x38>           <== ALWAYS TAKEN
 2008610:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 2008614:	30 80 00 08 	b,a   2008634 <timer_create+0x54>              <== NOT EXECUTED
         ( 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 )                                         
 2008618:	80 a0 60 00 	cmp  %g1, 0                                    
 200861c:	32 80 00 03 	bne,a   2008628 <timer_create+0x48>            <== ALWAYS TAKEN
 2008620:	82 00 7f ff 	add  %g1, -1, %g1                              
 2008624:	30 80 00 04 	b,a   2008634 <timer_create+0x54>              <== NOT EXECUTED
       rtems_set_errno_and_return_minus_one( EINVAL );                
                                                                      
     if ( !is_valid_signo(evp->sigev_signo) )                         
 2008628:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
 200862c:	28 80 00 06 	bleu,a   2008644 <timer_create+0x64>           <== ALWAYS TAKEN
 2008630:	03 00 80 88 	sethi  %hi(0x2022000), %g1                     
       rtems_set_errno_and_return_minus_one( EINVAL );                
 2008634:	40 00 23 d7 	call  2011590 <__errno>                        
 2008638:	01 00 00 00 	nop                                            
 200863c:	10 80 00 10 	b  200867c <timer_create+0x9c>                 
 2008640:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
   *                                                                  
   * 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;                  
 2008644:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2                        
                                                                      
    ++level;                                                          
 2008648:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
 200864c:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
 *  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 );
 2008650:	11 00 80 88 	sethi  %hi(0x2022000), %o0                     
 2008654:	40 00 08 6e 	call  200a80c <_Objects_Allocate>              
 2008658:	90 12 23 a4 	or  %o0, 0x3a4, %o0	! 20223a4 <_POSIX_Timer_Information>
                                                                      
  /*                                                                  
   *  Allocate a timer                                                
   */                                                                 
  ptimer = _POSIX_Timer_Allocate();                                   
  if ( !ptimer ) {                                                    
 200865c:	80 a2 20 00 	cmp  %o0, 0                                    
 2008660:	12 80 00 0a 	bne  2008688 <timer_create+0xa8>               
 2008664:	82 10 20 02 	mov  2, %g1                                    
    _Thread_Enable_dispatch();                                        
 2008668:	40 00 0d a0 	call  200bce8 <_Thread_Enable_dispatch>        
 200866c:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EAGAIN );                   
 2008670:	40 00 23 c8 	call  2011590 <__errno>                        
 2008674:	01 00 00 00 	nop                                            
 2008678:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
 200867c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2008680:	81 c7 e0 08 	ret                                            
 2008684:	91 e8 3f ff 	restore  %g0, -1, %o0                          
  }                                                                   
                                                                      
  /* The data of the created timer are stored to use them later */    
                                                                      
  ptimer->state     = POSIX_TIMER_STATE_CREATE_NEW;                   
 2008688:	c2 2a 20 3c 	stb  %g1, [ %o0 + 0x3c ]                       
  ptimer->thread_id = _Thread_Executing->Object.id;                   
 200868c:	03 00 80 89 	sethi  %hi(0x2022400), %g1                     
 2008690:	c2 00 62 00 	ld  [ %g1 + 0x200 ], %g1	! 2022600 <_Per_CPU_Information+0x10>
                                                                      
  if ( evp != NULL ) {                                                
 2008694:	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;                   
 2008698:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
                                                                      
  if ( evp != NULL ) {                                                
 200869c:	02 80 00 08 	be  20086bc <timer_create+0xdc>                
 20086a0:	c2 22 20 38 	st  %g1, [ %o0 + 0x38 ]                        
    ptimer->inf.sigev_notify = evp->sigev_notify;                     
 20086a4:	c2 06 40 00 	ld  [ %i1 ], %g1                               
 20086a8:	c2 22 20 40 	st  %g1, [ %o0 + 0x40 ]                        
    ptimer->inf.sigev_signo  = evp->sigev_signo;                      
 20086ac:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
 20086b0:	c2 22 20 44 	st  %g1, [ %o0 + 0x44 ]                        
    ptimer->inf.sigev_value  = evp->sigev_value;                      
 20086b4:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
 20086b8:	c2 22 20 48 	st  %g1, [ %o0 + 0x48 ]                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 20086bc:	c4 12 20 0a 	lduh  [ %o0 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 20086c0:	07 00 80 88 	sethi  %hi(0x2022000), %g3                     
 20086c4:	c6 00 e3 c0 	ld  [ %g3 + 0x3c0 ], %g3	! 20223c0 <_POSIX_Timer_Information+0x1c>
  }                                                                   
                                                                      
  ptimer->overrun  = 0;                                               
 20086c8:	c0 22 20 68 	clr  [ %o0 + 0x68 ]                            
  ptimer->timer_data.it_value.tv_sec     = 0;                         
 20086cc:	c0 22 20 5c 	clr  [ %o0 + 0x5c ]                            
  ptimer->timer_data.it_value.tv_nsec    = 0;                         
 20086d0:	c0 22 20 60 	clr  [ %o0 + 0x60 ]                            
  ptimer->timer_data.it_interval.tv_sec  = 0;                         
 20086d4:	c0 22 20 54 	clr  [ %o0 + 0x54 ]                            
  ptimer->timer_data.it_interval.tv_nsec = 0;                         
 20086d8:	c0 22 20 58 	clr  [ %o0 + 0x58 ]                            
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 20086dc:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
 20086e0:	c0 22 20 2c 	clr  [ %o0 + 0x2c ]                            
  the_watchdog->id        = id;                                       
 20086e4:	c0 22 20 30 	clr  [ %o0 + 0x30 ]                            
  the_watchdog->user_data = user_data;                                
 20086e8:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
 20086ec:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
 20086f0:	85 28 a0 02 	sll  %g2, 2, %g2                               
 20086f4:	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;                                   
 20086f8:	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;                                      
 20086fc:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  _Thread_Enable_dispatch();                                          
 2008700:	40 00 0d 7a 	call  200bce8 <_Thread_Enable_dispatch>        
 2008704:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
 2008708:	81 c7 e0 08 	ret                                            
 200870c:	81 e8 00 00 	restore                                        
                                                                      

020071e8 <timer_settime>: timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) {
 20071e8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  Objects_Locations    location;                                      
  bool                 activated;                                     
  uint32_t             initial_period;                                
  struct itimerspec    normalize;                                     
                                                                      
  if ( !value )                                                       
 20071ec:	80 a6 a0 00 	cmp  %i2, 0                                    
 20071f0:	02 80 00 80 	be  20073f0 <timer_settime+0x208>              <== NEVER TAKEN
 20071f4:	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) ) ) {                  
 20071f8:	40 00 0f 83 	call  200b004 <_Timespec_Is_valid>             
 20071fc:	90 06 a0 08 	add  %i2, 8, %o0                               
 2007200:	80 8a 20 ff 	btst  0xff, %o0                                
 2007204:	02 80 00 7b 	be  20073f0 <timer_settime+0x208>              
 2007208:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
  if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {               
 200720c:	40 00 0f 7e 	call  200b004 <_Timespec_Is_valid>             
 2007210:	90 10 00 1a 	mov  %i2, %o0                                  
 2007214:	80 8a 20 ff 	btst  0xff, %o0                                
 2007218:	02 80 00 76 	be  20073f0 <timer_settime+0x208>              <== NEVER TAKEN
 200721c:	80 8e 7f fb 	btst  -5, %i1                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {    
 2007220:	12 80 00 74 	bne  20073f0 <timer_settime+0x208>             
 2007224:	90 07 bf f0 	add  %fp, -16, %o0                             
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  normalize = *value;                                                 
 2007228:	92 10 00 1a 	mov  %i2, %o1                                  
 200722c:	40 00 25 91 	call  2010870 <memcpy>                         
 2007230:	94 10 20 10 	mov  0x10, %o2                                 
                                                                      
  /* Convert absolute to relative time */                             
  if (flags == TIMER_ABSTIME) {                                       
 2007234:	80 a6 60 04 	cmp  %i1, 4                                    
 2007238:	12 80 00 1f 	bne  20072b4 <timer_settime+0xcc>              
 200723c:	11 00 80 78 	sethi  %hi(0x201e000), %o0                     
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
 2007240:	90 07 bf e0 	add  %fp, -32, %o0                             
 2007244:	13 00 80 77 	sethi  %hi(0x201dc00), %o1                     
 2007248:	40 00 06 74 	call  2008c18 <_TOD_Get_with_nanoseconds>      
 200724c:	92 12 63 68 	or  %o1, 0x368, %o1	! 201df68 <_TOD>           
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
 2007250:	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);           
 2007254:	94 10 20 00 	clr  %o2                                       
 2007258:	90 10 00 1c 	mov  %i4, %o0                                  
 200725c:	92 10 00 1d 	mov  %i5, %o1                                  
 2007260:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2007264:	40 00 48 ed 	call  2019618 <__divdi3>                       
 2007268:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 200726c:	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);           
 2007270:	d2 27 bf e8 	st  %o1, [ %fp + -24 ]                         
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 2007274:	90 10 00 1c 	mov  %i4, %o0                                  
 2007278:	92 10 00 1d 	mov  %i5, %o1                                  
 200727c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 2007280:	40 00 49 d1 	call  20199c4 <__moddi3>                       
 2007284:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  /* 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 ) )        
 2007288:	90 07 bf f8 	add  %fp, -8, %o0                              
 200728c:	d2 27 bf ec 	st  %o1, [ %fp + -20 ]                         
 2007290:	40 00 0f 6f 	call  200b04c <_Timespec_Less_than>            
 2007294:	92 07 bf e8 	add  %fp, -24, %o1                             
 2007298:	80 8a 20 ff 	btst  0xff, %o0                                
 200729c:	12 80 00 55 	bne  20073f0 <timer_settime+0x208>             
 20072a0:	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 );
 20072a4:	90 07 bf e8 	add  %fp, -24, %o0                             
 20072a8:	40 00 0f 79 	call  200b08c <_Timespec_Subtract>             
 20072ac:	94 10 00 09 	mov  %o1, %o2                                  
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (          
  timer_t            id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (POSIX_Timer_Control *)                                      
 20072b0:	11 00 80 78 	sethi  %hi(0x201e000), %o0                     
 20072b4:	92 10 00 18 	mov  %i0, %o1                                  
 20072b8:	90 12 22 f4 	or  %o0, 0x2f4, %o0                            
 20072bc:	40 00 08 fe 	call  20096b4 <_Objects_Get>                   
 20072c0:	94 07 bf dc 	add  %fp, -36, %o2                             
   * something with the structure of times of the timer: to stop, start
   * or start it again                                                
   */                                                                 
                                                                      
  ptimer = _POSIX_Timer_Get( timerid, &location );                    
  switch ( location ) {                                               
 20072c4:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
 20072c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20072cc:	12 80 00 49 	bne  20073f0 <timer_settime+0x208>             
 20072d0:	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 ) {
 20072d4:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
 20072d8:	80 a0 60 00 	cmp  %g1, 0                                    
 20072dc:	12 80 00 14 	bne  200732c <timer_settime+0x144>             
 20072e0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
 20072e4:	80 a0 60 00 	cmp  %g1, 0                                    
 20072e8:	12 80 00 11 	bne  200732c <timer_settime+0x144>             
 20072ec:	01 00 00 00 	nop                                            
         /* Stop the timer */                                         
         (void) _Watchdog_Remove( &ptimer->Timer );                   
 20072f0:	40 00 10 75 	call  200b4c4 <_Watchdog_Remove>               
 20072f4:	90 02 20 10 	add  %o0, 0x10, %o0                            
         /* The old data of the timer are returned */                 
         if ( ovalue )                                                
 20072f8:	80 a6 e0 00 	cmp  %i3, 0                                    
 20072fc:	02 80 00 05 	be  2007310 <timer_settime+0x128>              
 2007300:	90 10 00 1b 	mov  %i3, %o0                                  
           *ovalue = ptimer->timer_data;                              
 2007304:	92 06 60 54 	add  %i1, 0x54, %o1                            
 2007308:	40 00 25 5a 	call  2010870 <memcpy>                         
 200730c:	94 10 20 10 	mov  0x10, %o2                                 
         /* The new data are set */                                   
         ptimer->timer_data = normalize;                              
 2007310:	90 06 60 54 	add  %i1, 0x54, %o0                            
 2007314:	92 07 bf f0 	add  %fp, -16, %o1                             
 2007318:	40 00 25 56 	call  2010870 <memcpy>                         
 200731c:	94 10 20 10 	mov  0x10, %o2                                 
         /* Indicates that the timer is created and stopped */        
         ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;               
 2007320:	82 10 20 04 	mov  4, %g1                                    
 2007324:	10 80 00 2f 	b  20073e0 <timer_settime+0x1f8>               
 2007328:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
        _Thread_Enable_dispatch();                                    
        return 0;                                                     
       }                                                              
                                                                      
       /* Convert from seconds and nanoseconds to ticks */            
       ptimer->ticks  = _Timespec_To_ticks( &value->it_interval );    
 200732c:	40 00 0f 69 	call  200b0d0 <_Timespec_To_ticks>             
 2007330:	90 10 00 1a 	mov  %i2, %o0                                  
 2007334:	d0 26 60 64 	st  %o0, [ %i1 + 0x64 ]                        
       initial_period = _Timespec_To_ticks( &normalize.it_value );    
 2007338:	40 00 0f 66 	call  200b0d0 <_Timespec_To_ticks>             
 200733c:	90 07 bf f8 	add  %fp, -8, %o0                              
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
 2007340:	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 );    
 2007344:	92 10 00 08 	mov  %o0, %o1                                  
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
 2007348:	17 00 80 1d 	sethi  %hi(0x2007400), %o3                     
 200734c:	90 06 60 10 	add  %i1, 0x10, %o0                            
 2007350:	96 12 e0 08 	or  %o3, 8, %o3                                
 2007354:	40 00 18 79 	call  200d538 <_POSIX_Timer_Insert_helper>     
 2007358:	98 10 00 19 	mov  %i1, %o4                                  
         initial_period,                                              
         ptimer->Object.id,                                           
         _POSIX_Timer_TSR,                                            
         ptimer                                                       
       );                                                             
       if ( !activated ) {                                            
 200735c:	80 8a 20 ff 	btst  0xff, %o0                                
 2007360:	02 80 00 20 	be  20073e0 <timer_settime+0x1f8>              
 2007364:	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 )                                                  
 2007368:	02 80 00 05 	be  200737c <timer_settime+0x194>              
 200736c:	90 10 00 1b 	mov  %i3, %o0                                  
         *ovalue = ptimer->timer_data;                                
 2007370:	92 06 60 54 	add  %i1, 0x54, %o1                            
 2007374:	40 00 25 3f 	call  2010870 <memcpy>                         
 2007378:	94 10 20 10 	mov  0x10, %o2                                 
       ptimer->timer_data = normalize;                                
 200737c:	94 10 20 10 	mov  0x10, %o2                                 
 2007380:	92 07 bf f0 	add  %fp, -16, %o1                             
 2007384:	40 00 25 3b 	call  2010870 <memcpy>                         
 2007388:	90 06 60 54 	add  %i1, 0x54, %o0                            
                                                                      
       /* Indicate that the time is running */                        
       ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                  
 200738c:	82 10 20 03 	mov  3, %g1                                    
 2007390:	90 07 bf e0 	add  %fp, -32, %o0                             
 2007394:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
 2007398:	13 00 80 77 	sethi  %hi(0x201dc00), %o1                     
 200739c:	40 00 06 1f 	call  2008c18 <_TOD_Get_with_nanoseconds>      
 20073a0:	92 12 63 68 	or  %o1, 0x368, %o1	! 201df68 <_TOD>           
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
 20073a4:	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);           
 20073a8:	94 10 20 00 	clr  %o2                                       
 20073ac:	90 10 00 1c 	mov  %i4, %o0                                  
 20073b0:	92 10 00 1d 	mov  %i5, %o1                                  
 20073b4:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 20073b8:	40 00 48 98 	call  2019618 <__divdi3>                       
 20073bc:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 20073c0:	90 10 00 1c 	mov  %i4, %o0                                  
static inline void _Timestamp64_implementation_To_timespec(           
  const Timestamp64_Control *_timestamp,                              
  struct timespec           *_timespec                                
)                                                                     
{                                                                     
  _timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);           
 20073c4:	d2 26 60 6c 	st  %o1, [ %i1 + 0x6c ]                        
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
 20073c8:	94 10 20 00 	clr  %o2                                       
 20073cc:	92 10 00 1d 	mov  %i5, %o1                                  
 20073d0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
 20073d4:	40 00 49 7c 	call  20199c4 <__moddi3>                       
 20073d8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_END+0x395aca00>
 20073dc:	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();                                     
 20073e0:	40 00 0c 6d 	call  200a594 <_Thread_Enable_dispatch>        
 20073e4:	b0 10 20 00 	clr  %i0                                       
 20073e8:	81 c7 e0 08 	ret                                            
 20073ec:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
 20073f0:	40 00 22 cf 	call  200ff2c <__errno>                        
 20073f4:	b0 10 3f ff 	mov  -1, %i0                                   
 20073f8:	82 10 20 16 	mov  0x16, %g1                                 
 20073fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
 2007400:	81 c7 e0 08 	ret                                            
 2007404:	81 e8 00 00 	restore                                        
                                                                      

020073b8 <ualarm>: useconds_t ualarm( useconds_t useconds, useconds_t interval ) {
 20073b8:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Initialize the timer used to implement alarm().                 
   */                                                                 
                                                                      
  if ( !the_timer->routine ) {                                        
 20073bc:	3b 00 80 7e 	sethi  %hi(0x201f800), %i5                     
 20073c0:	ba 17 62 98 	or  %i5, 0x298, %i5	! 201fa98 <_POSIX_signals_Ualarm_timer>
 20073c4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
 20073c8:	80 a0 60 00 	cmp  %g1, 0                                    
 20073cc:	12 80 00 0a 	bne  20073f4 <ualarm+0x3c>                     
 20073d0:	b8 10 00 18 	mov  %i0, %i4                                  
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
 20073d4:	03 00 80 1c 	sethi  %hi(0x2007000), %g1                     
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
 20073d8:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  the_watchdog->routine   = routine;                                  
 20073dc:	82 10 63 8c 	or  %g1, 0x38c, %g1                            
  the_watchdog->id        = id;                                       
 20073e0:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
 20073e4:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
 20073e8:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
useconds_t ualarm(                                                    
  useconds_t useconds,                                                
  useconds_t interval                                                 
)                                                                     
{                                                                     
  useconds_t        remaining = 0;                                    
 20073ec:	10 80 00 1b 	b  2007458 <ualarm+0xa0>                       
 20073f0:	b0 10 20 00 	clr  %i0                                       
  if ( !the_timer->routine ) {                                        
    _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
  } else {                                                            
    Watchdog_States state;                                            
                                                                      
    state = _Watchdog_Remove( the_timer );                            
 20073f4:	40 00 0f f1 	call  200b3b8 <_Watchdog_Remove>               
 20073f8:	90 10 00 1d 	mov  %i5, %o0                                  
    if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
 20073fc:	90 02 3f fe 	add  %o0, -2, %o0                              
 2007400:	80 a2 20 01 	cmp  %o0, 1                                    
 2007404:	18 80 00 15 	bgu  2007458 <ualarm+0xa0>                     <== NEVER TAKEN
 2007408:	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);        
 200740c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2007410:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
 2007414:	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);        
 2007418:	90 02 00 01 	add  %o0, %g1, %o0                             
 200741c:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
 2007420:	40 00 0e ac 	call  200aed0 <_Timespec_From_ticks>           
 2007424:	90 22 00 01 	sub  %o0, %g1, %o0                             
      remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;           
 2007428:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
      remaining += tp.tv_nsec / 1000;                                 
 200742c:	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;           
 2007430:	85 28 60 03 	sll  %g1, 3, %g2                               
 2007434:	87 28 60 08 	sll  %g1, 8, %g3                               
 2007438:	84 20 c0 02 	sub  %g3, %g2, %g2                             
      remaining += tp.tv_nsec / 1000;                                 
 200743c:	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;           
 2007440:	b1 28 a0 06 	sll  %g2, 6, %i0                               
 2007444:	b0 26 00 02 	sub  %i0, %g2, %i0                             
      remaining += tp.tv_nsec / 1000;                                 
 2007448:	40 00 4b fa 	call  201a430 <.div>                           
 200744c:	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;           
 2007450:	b1 2e 20 06 	sll  %i0, 6, %i0                               
      remaining += tp.tv_nsec / 1000;                                 
 2007454:	b0 02 00 18 	add  %o0, %i0, %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 ) {                                                   
 2007458:	80 a7 20 00 	cmp  %i4, 0                                    
 200745c:	02 80 00 19 	be  20074c0 <ualarm+0x108>                     
 2007460:	3b 00 03 d0 	sethi  %hi(0xf4000), %i5                       
    Watchdog_Interval ticks;                                          
                                                                      
    tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;               
 2007464:	90 10 00 1c 	mov  %i4, %o0                                  
 2007468:	40 00 4b f0 	call  201a428 <.udiv>                          
 200746c:	92 17 62 40 	or  %i5, 0x240, %o1                            
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
 2007470:	92 17 62 40 	or  %i5, 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;               
 2007474:	d0 27 bf f8 	st  %o0, [ %fp + -8 ]                          
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
 2007478:	40 00 4c 98 	call  201a6d8 <.urem>                          
 200747c:	90 10 00 1c 	mov  %i4, %o0                                  
 2007480:	85 2a 20 07 	sll  %o0, 7, %g2                               
 2007484:	83 2a 20 02 	sll  %o0, 2, %g1                               
 2007488:	82 20 80 01 	sub  %g2, %g1, %g1                             
 200748c:	90 00 40 08 	add  %g1, %o0, %o0                             
 2007490:	91 2a 20 03 	sll  %o0, 3, %o0                               
 2007494:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
    ticks = _Timespec_To_ticks( &tp );                                
 2007498:	40 00 0e a3 	call  200af24 <_Timespec_To_ticks>             
 200749c:	90 07 bf f8 	add  %fp, -8, %o0                              
    if ( ticks == 0 )                                                 
      ticks = 1;                                                      
                                                                      
    _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );   
 20074a0:	40 00 0e a1 	call  200af24 <_Timespec_To_ticks>             
 20074a4:	90 07 bf f8 	add  %fp, -8, %o0                              
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
 20074a8:	13 00 80 7e 	sethi  %hi(0x201f800), %o1                     
 20074ac:	92 12 62 98 	or  %o1, 0x298, %o1	! 201fa98 <_POSIX_signals_Ualarm_timer>
 20074b0:	d0 22 60 0c 	st  %o0, [ %o1 + 0xc ]                         
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
 20074b4:	11 00 80 7c 	sethi  %hi(0x201f000), %o0                     
 20074b8:	40 00 0f 68 	call  200b258 <_Watchdog_Insert>               
 20074bc:	90 12 22 3c 	or  %o0, 0x23c, %o0	! 201f23c <_Watchdog_Ticks_chain>
  }                                                                   
                                                                      
  return remaining;                                                   
}                                                                     
 20074c0:	81 c7 e0 08 	ret                                            
 20074c4:	81 e8 00 00 	restore                                        
                                                                      

02006f80 <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 ) {
 2006f80:	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 =                
 2006f84:	94 10 20 18 	mov  0x18, %o2                                 
 2006f88:	92 10 00 18 	mov  %i0, %o1                                  
 2006f8c:	7f ff f6 fa 	call  2004b74 <rtems_filesystem_eval_path_start>
 2006f90:	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;
 2006f94:	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)(                         
 2006f98:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
 2006f9c:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
 2006fa0:	9f c0 40 00 	call  %g1                                      
 2006fa4:	d2 07 60 24 	ld  [ %i5 + 0x24 ], %o1                        
                                                                      
  if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {   
 2006fa8:	80 8a 20 ff 	btst  0xff, %o0                                
 2006fac:	02 80 00 26 	be  2007044 <unmount+0xc4>                     
 2006fb0:	03 00 80 74 	sethi  %hi(0x201d000), %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;                                 
 2006fb4:	c2 00 60 68 	ld  [ %g1 + 0x68 ], %g1	! 201d068 <rtems_current_user_env>
  const rtems_filesystem_location_info_t *current =                   
    &rtems_filesystem_current->location;                              
 2006fb8:	c4 00 40 00 	ld  [ %g1 ], %g2                               
                                                                      
  return mt_entry == root->mt_entry || mt_entry == current->mt_entry; 
 2006fbc:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
 2006fc0:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
 2006fc4:	80 a7 40 01 	cmp  %i5, %g1                                  
 2006fc8:	22 80 00 06 	be,a   2006fe0 <unmount+0x60>                  
 2006fcc:	82 10 20 01 	mov  1, %g1                                    
 2006fd0:	c2 00 a0 14 	ld  [ %g2 + 0x14 ], %g1                        
 2006fd4:	82 1f 40 01 	xor  %i5, %g1, %g1                             
 2006fd8:	80 a0 00 01 	cmp  %g0, %g1                                  
 2006fdc:	82 60 3f ff 	subx  %g0, -1, %g1                             
  const rtems_filesystem_location_info_t *currentloc =                
    rtems_filesystem_eval_path_start( &ctx, path, eval_flags );       
  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 ) ) {          
 2006fe0:	80 a0 60 00 	cmp  %g1, 0                                    
 2006fe4:	12 80 00 14 	bne  2007034 <unmount+0xb4>                    
 2006fe8:	01 00 00 00 	nop                                            
      const rtems_filesystem_operations_table *mt_point_ops =         
        mt_entry->mt_point_node->location.mt_entry->ops;              
 2006fec:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
 2006ff0:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
                                                                      
      rv = (*mt_point_ops->unmount_h)( mt_entry );                    
 2006ff4:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2006ff8:	c2 00 60 38 	ld  [ %g1 + 0x38 ], %g1                        
 2006ffc:	9f c0 40 00 	call  %g1                                      
 2007000:	90 10 00 1d 	mov  %i5, %o0                                  
      if ( rv == 0 ) {                                                
 2007004:	b0 92 20 00 	orcc  %o0, 0, %i0                              
 2007008:	12 80 00 14 	bne  2007058 <unmount+0xd8>                    
 200700c:	01 00 00 00 	nop                                            
        rtems_id self_task_id = rtems_task_self();                    
 2007010:	40 00 03 f6 	call  2007fe8 <rtems_task_self>                
 2007014:	01 00 00 00 	nop                                            
        rtems_filesystem_mt_entry_declare_lock_context( lock_context );
                                                                      
        rtems_filesystem_mt_entry_lock( lock_context );               
 2007018:	7f ff ed 3e 	call  2002510 <sparc_disable_interrupts>       
 200701c:	b8 10 00 08 	mov  %o0, %i4                                  
        mt_entry->unmount_task = self_task_id;                        
 2007020:	f8 27 60 3c 	st  %i4, [ %i5 + 0x3c ]                        
        mt_entry->mounted = false;                                    
 2007024:	c0 2f 60 28 	clrb  [ %i5 + 0x28 ]                           
        rtems_filesystem_mt_entry_unlock( lock_context );             
 2007028:	7f ff ed 3e 	call  2002520 <sparc_enable_interrupts>        
 200702c:	01 00 00 00 	nop                                            
 2007030:	30 80 00 0a 	b,a   2007058 <unmount+0xd8>                   
      }                                                               
    } else {                                                          
      errno = EBUSY;                                                  
 2007034:	40 00 22 ad 	call  200fae8 <__errno>                        
 2007038:	01 00 00 00 	nop                                            
 200703c:	10 80 00 05 	b  2007050 <unmount+0xd0>                      
 2007040:	82 10 20 10 	mov  0x10, %g1	! 10 <PROM_START+0x10>          
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EACCES;                                                   
 2007044:	40 00 22 a9 	call  200fae8 <__errno>                        
 2007048:	01 00 00 00 	nop                                            
 200704c:	82 10 20 0d 	mov  0xd, %g1	! d <PROM_START+0xd>             
 2007050:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    rv = -1;                                                          
 2007054:	b0 10 3f ff 	mov  -1, %i0                                   
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
 2007058:	7f ff f7 03 	call  2004c64 <rtems_filesystem_eval_path_cleanup>
 200705c:	90 07 bf c8 	add  %fp, -56, %o0                             
                                                                      
  if ( rv == 0 ) {                                                    
 2007060:	80 a6 20 00 	cmp  %i0, 0                                    
 2007064:	12 80 00 0b 	bne  2007090 <unmount+0x110>                   
 2007068:	11 20 00 00 	sethi  %hi(0x80000000), %o0                    
  rtems_interval ticks                                                
)                                                                     
{                                                                     
  rtems_event_set event_out;                                          
                                                                      
  return rtems_event_system_receive(                                  
 200706c:	92 10 20 00 	clr  %o1                                       
 2007070:	94 10 20 00 	clr  %o2                                       
 2007074:	40 00 03 19 	call  2007cd8 <rtems_event_system_receive>     
 2007078:	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 ) {                                   
 200707c:	80 a2 20 00 	cmp  %o0, 0                                    
 2007080:	02 80 00 04 	be  2007090 <unmount+0x110>                    <== ALWAYS TAKEN
 2007084:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred( 0xdeadbeef );                       
 2007088:	40 00 04 89 	call  20082ac <rtems_fatal_error_occurred>     <== NOT EXECUTED
 200708c:	90 12 22 ef 	or  %o0, 0x2ef, %o0	! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
 2007090:	81 c7 e0 08 	ret                                            
 2007094:	81 e8 00 00 	restore                                        
                                                                      

02019ef4 <write>: ssize_t write( int fd, const void *buffer, size_t count ) {
 2019ef4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
 2019ef8:	03 00 80 72 	sethi  %hi(0x201c800), %g1                     
 2019efc:	c2 00 61 f4 	ld  [ %g1 + 0x1f4 ], %g1	! 201c9f4 <rtems_libio_number_iops>
 2019f00:	80 a6 00 01 	cmp  %i0, %g1                                  
 2019f04:	1a 80 00 16 	bcc  2019f5c <write+0x68>                      
 2019f08:	83 2e 20 03 	sll  %i0, 3, %g1                               
  iop = rtems_libio_iop( fd );                                        
 2019f0c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2019f10:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2019f14:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2019f18:	d0 00 60 44 	ld  [ %g1 + 0x44 ], %o0	! 201d444 <rtems_libio_iops>
 2019f1c:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open( iop );                                   
 2019f20:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
 2019f24:	80 88 61 00 	btst  0x100, %g1                               
 2019f28:	02 80 00 0d 	be  2019f5c <write+0x68>                       
 2019f2c:	80 a6 60 00 	cmp  %i1, 0                                    
  rtems_libio_check_buffer( buffer );                                 
 2019f30:	12 80 00 06 	bne  2019f48 <write+0x54>                      <== ALWAYS TAKEN
 2019f34:	80 a6 a0 00 	cmp  %i2, 0                                    
 2019f38:	7f ff d5 cd 	call  200f66c <__errno>                        <== NOT EXECUTED
 2019f3c:	01 00 00 00 	nop                                            <== NOT EXECUTED
 2019f40:	10 80 00 0a 	b  2019f68 <write+0x74>                        <== NOT EXECUTED
 2019f44:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
  rtems_libio_check_count( count );                                   
 2019f48:	02 80 00 10 	be  2019f88 <write+0x94>                       
 2019f4c:	b0 10 20 00 	clr  %i0                                       
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
 2019f50:	80 88 60 04 	btst  4, %g1                                   
 2019f54:	32 80 00 08 	bne,a   2019f74 <write+0x80>                   
 2019f58:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
 2019f5c:	7f ff d5 c4 	call  200f66c <__errno>                        
 2019f60:	01 00 00 00 	nop                                            
 2019f64:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
 2019f68:	c2 22 00 00 	st  %g1, [ %o0 ]                               
 2019f6c:	81 c7 e0 08 	ret                                            
 2019f70:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      
  /*                                                                  
   *  Now process the write() request.                                
   */                                                                 
  return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );    
 2019f74:	92 10 00 19 	mov  %i1, %o1                                  
 2019f78:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2019f7c:	9f c0 40 00 	call  %g1                                      
 2019f80:	94 10 00 1a 	mov  %i2, %o2                                  
 2019f84:	b0 10 00 08 	mov  %o0, %i0                                  
}                                                                     
 2019f88:	81 c7 e0 08 	ret                                            
 2019f8c:	81 e8 00 00 	restore                                        
                                                                      

02007e84 <writev>: ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) {
 2007e84:	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 );                                         
 2007e88:	03 00 80 75 	sethi  %hi(0x201d400), %g1                     
 2007e8c:	c2 00 60 f4 	ld  [ %g1 + 0xf4 ], %g1	! 201d4f4 <rtems_libio_number_iops>
 2007e90:	80 a6 00 01 	cmp  %i0, %g1                                  
 2007e94:	2a 80 00 03 	bcs,a   2007ea0 <writev+0x1c>                  
 2007e98:	83 2e 20 03 	sll  %i0, 3, %g1                               
 2007e9c:	30 80 00 0c 	b,a   2007ecc <writev+0x48>                    
  iop = rtems_libio_iop( fd );                                        
 2007ea0:	b1 2e 20 06 	sll  %i0, 6, %i0                               
 2007ea4:	b0 26 00 01 	sub  %i0, %g1, %i0                             
 2007ea8:	03 00 80 77 	sethi  %hi(0x201dc00), %g1                     
 2007eac:	f8 00 63 44 	ld  [ %g1 + 0x344 ], %i4	! 201df44 <rtems_libio_iops>
 2007eb0:	b8 07 00 18 	add  %i4, %i0, %i4                             
  rtems_libio_check_is_open( iop );                                   
 2007eb4:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
 2007eb8:	80 88 61 00 	btst  0x100, %g1                               
 2007ebc:	02 80 00 04 	be  2007ecc <writev+0x48>                      
 2007ec0:	80 88 60 04 	btst  4, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
 2007ec4:	12 80 00 06 	bne  2007edc <writev+0x58>                     <== ALWAYS TAKEN
 2007ec8:	80 a6 60 00 	cmp  %i1, 0                                    
 2007ecc:	40 00 21 37 	call  20103a8 <__errno>                        
 2007ed0:	01 00 00 00 	nop                                            
 2007ed4:	10 80 00 20 	b  2007f54 <writev+0xd0>                       
 2007ed8:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
 2007edc:	02 80 00 1b 	be  2007f48 <writev+0xc4>                      
 2007ee0:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
 2007ee4:	04 80 00 19 	ble  2007f48 <writev+0xc4>                     
 2007ee8:	80 a6 a4 00 	cmp  %i2, 0x400                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
 2007eec:	24 80 00 03 	ble,a   2007ef8 <writev+0x74>                  <== ALWAYS TAKEN
 2007ef0:	b5 2e a0 03 	sll  %i2, 3, %i2                               
 2007ef4:	30 80 00 15 	b,a   2007f48 <writev+0xc4>                    <== NOT EXECUTED
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
 2007ef8:	82 10 20 00 	clr  %g1                                       
 2007efc:	86 10 20 01 	mov  1, %g3                                    
 2007f00:	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 )                                       
 2007f04:	c8 06 40 01 	ld  [ %i1 + %g1 ], %g4                         
 2007f08:	80 a1 20 00 	cmp  %g4, 0                                    
 2007f0c:	02 80 00 0f 	be  2007f48 <writev+0xc4>                      
 2007f10:	88 06 40 01 	add  %i1, %g1, %g4                             
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
 2007f14:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
      all_zeros = false;                                              
 2007f18:	80 a0 00 04 	cmp  %g0, %g4                                  
 2007f1c:	ba 40 3f ff 	addx  %g0, -1, %i5                             
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
 2007f20:	88 81 00 02 	addcc  %g4, %g2, %g4                           
 2007f24:	0c 80 00 09 	bneg  2007f48 <writev+0xc4>                    
 2007f28:	86 08 c0 1d 	and  %g3, %i5, %g3                             
 2007f2c:	80 a1 00 02 	cmp  %g4, %g2                                  
 2007f30:	06 80 00 03 	bl  2007f3c <writev+0xb8>                      
 2007f34:	ba 10 20 01 	mov  1, %i5                                    
 2007f38:	ba 10 20 00 	clr  %i5                                       
 2007f3c:	80 8f 60 ff 	btst  0xff, %i5                                
 2007f40:	02 80 00 07 	be  2007f5c <writev+0xd8>                      
 2007f44:	82 00 60 08 	add  %g1, 8, %g1                               
      rtems_set_errno_and_return_minus_one( EINVAL );                 
 2007f48:	40 00 21 18 	call  20103a8 <__errno>                        
 2007f4c:	01 00 00 00 	nop                                            
 2007f50:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
 2007f54:	10 80 00 21 	b  2007fd8 <writev+0x154>                      
 2007f58:	c2 22 00 00 	st  %g1, [ %o0 ]                               
   *  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++ ) {                    
 2007f5c:	80 a0 40 1a 	cmp  %g1, %i2                                  
 2007f60:	12 bf ff e9 	bne  2007f04 <writev+0x80>                     
 2007f64:	84 10 00 04 	mov  %g4, %g2                                  
  }                                                                   
                                                                      
  /*                                                                  
   * A writev with all zeros is supposed to have no effect per OpenGroup.
   */                                                                 
  if ( all_zeros == true ) {                                          
 2007f68:	80 88 e0 ff 	btst  0xff, %g3                                
 2007f6c:	12 80 00 19 	bne  2007fd0 <writev+0x14c>                    
 2007f70:	b0 10 20 00 	clr  %i0                                       
 2007f74:	ba 10 20 00 	clr  %i5                                       
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
 2007f78:	b6 06 40 1d 	add  %i1, %i5, %i3                             
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    /* all zero lengths has no effect */                              
    if ( iov[v].iov_len == 0 )                                        
 2007f7c:	d4 06 e0 04 	ld  [ %i3 + 4 ], %o2                           
 2007f80:	80 a2 a0 00 	cmp  %o2, 0                                    
 2007f84:	22 80 00 10 	be,a   2007fc4 <writev+0x140>                  <== NEVER TAKEN
 2007f88:	ba 07 60 08 	add  %i5, 8, %i5                               <== NOT EXECUTED
      continue;                                                       
                                                                      
    bytes = (*iop->pathinfo.handlers->write_h)(                       
 2007f8c:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
 2007f90:	d2 06 40 1d 	ld  [ %i1 + %i5 ], %o1                         
 2007f94:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
 2007f98:	9f c0 40 00 	call  %g1                                      
 2007f9c:	90 10 00 1c 	mov  %i4, %o0                                  
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
 2007fa0:	80 a2 20 00 	cmp  %o0, 0                                    
 2007fa4:	26 80 00 0b 	bl,a   2007fd0 <writev+0x14c>                  <== NEVER TAKEN
 2007fa8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
 2007fac:	32 80 00 02 	bne,a   2007fb4 <writev+0x130>                 <== ALWAYS TAKEN
 2007fb0:	b0 06 00 08 	add  %i0, %o0, %i0                             
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
 2007fb4:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
 2007fb8:	80 a2 00 01 	cmp  %o0, %g1                                  
 2007fbc:	12 80 00 05 	bne  2007fd0 <writev+0x14c>                    <== NEVER TAKEN
 2007fc0:	ba 07 60 08 	add  %i5, 8, %i5                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
 2007fc4:	80 a7 40 1a 	cmp  %i5, %i2                                  
 2007fc8:	12 bf ff ed 	bne  2007f7c <writev+0xf8>                     
 2007fcc:	b6 06 40 1d 	add  %i1, %i5, %i3                             
 2007fd0:	81 c7 e0 08 	ret                                            
 2007fd4:	81 e8 00 00 	restore                                        
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
      return -1;                                                      
 2007fd8:	b0 10 3f ff 	mov  -1, %i0                                   
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
 2007fdc:	81 c7 e0 08 	ret                                            
 2007fe0:	81 e8 00 00 	restore